2006-12-31 01:02:27 +01:00
|
|
|
/* Copyright (C) 2000-2006 MySQL AB
|
2001-12-06 13:10:51 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
2006-12-23 20:17:15 +01:00
|
|
|
the Free Software Foundation; version 2 of the License.
|
2001-12-06 13:10:51 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
2001-12-06 13:10:51 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Some general useful functions */
|
|
|
|
|
|
|
|
|
|
#include "mysql_priv.h"
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
#include "sql_trigger.h"
|
2000-07-31 21:29:14 +02:00
|
|
|
#include <m_ctype.h>
|
2007-07-19 14:14:03 +02:00
|
|
|
#include "my_md5.h"
|
2000-07-31 21:29:14 +02:00
|
|
|
|
WL#3984 (Revise locking of mysql.general_log and mysql.slow_log)
Bug#25422 (Hang with log tables)
Bug 17876 (Truncating mysql.slow_log in a SP after using cursor locks the
thread)
Bug 23044 (Warnings on flush of a log table)
Bug 29129 (Resetting general_log while the GLOBAL READ LOCK is set causes
a deadlock)
Prior to this fix, the server would hang when performing concurrent
ALTER TABLE or TRUNCATE TABLE statements against the LOG TABLES,
which are mysql.general_log and mysql.slow_log.
The root cause traces to the following code:
in sql_base.cc, open_table()
if (table->in_use != thd)
{
/* wait_for_condition will unlock LOCK_open for us */
wait_for_condition(thd, &LOCK_open, &COND_refresh);
}
The problem with this code is that the current implementation of the
LOGGER creates 'fake' THD objects, like
- Log_to_csv_event_handler::general_log_thd
- Log_to_csv_event_handler::slow_log_thd
which are not associated to a real thread running in the server,
so that waiting for these non-existing threads to release table locks
cause the dead lock.
In general, the design of Log_to_csv_event_handler does not fit into the
general architecture of the server, so that the concept of general_log_thd
and slow_log_thd has to be abandoned:
- this implementation does not work with table locking
- it will not work with commands like SHOW PROCESSLIST
- having the log tables always opened does not integrate well with DDL
operations / FLUSH TABLES / SET GLOBAL READ_ONLY
With this patch, the fundamental design of the LOGGER has been changed to:
- always open and close a log table when writing a log
- remove totally the usage of fake THD objects
- clarify how locking of log tables is implemented in general.
See WL#3984 for details related to the new locking design.
Additional changes (misc bugs exposed and fixed):
1)
mysqldump which would ignore some tables in dump_all_tables_in_db(),
but forget to ignore the same in dump_all_views_in_db().
2)
mysqldump would also issue an empty "LOCK TABLE" command when all the tables
to lock are to be ignored (numrows == 0), instead of not issuing the query.
3)
Internal errors handlers could intercept errors but not warnings
(see sql_error.cc).
4)
Implementing a nested call to open tables, for the performance schema tables,
exposed an existing bug in remove_table_from_cache(), which would perform:
in_use->some_tables_deleted=1;
against another thread, without any consideration about thread locking.
This call inside remove_table_from_cache() was not required anyway,
since calling mysql_lock_abort() takes care of aborting -- cleanly -- threads
that might hold a lock on a table.
This line (in_use->some_tables_deleted=1) has been removed.
2007-07-27 08:31:06 +02:00
|
|
|
/* INFORMATION_SCHEMA name */
|
|
|
|
|
LEX_STRING INFORMATION_SCHEMA_NAME= {C_STRING_WITH_LEN("information_schema")};
|
|
|
|
|
|
|
|
|
|
/* MYSQL_SCHEMA name */
|
|
|
|
|
LEX_STRING MYSQL_SCHEMA_NAME= {C_STRING_WITH_LEN("mysql")};
|
|
|
|
|
|
|
|
|
|
/* GENERAL_LOG name */
|
|
|
|
|
LEX_STRING GENERAL_LOG_NAME= {C_STRING_WITH_LEN("general_log")};
|
|
|
|
|
|
|
|
|
|
/* SLOW_LOG name */
|
|
|
|
|
LEX_STRING SLOW_LOG_NAME= {C_STRING_WITH_LEN("slow_log")};
|
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
/* Functions defined in this file */
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
void open_table_error(TABLE_SHARE *share, int error, int db_errno,
|
|
|
|
|
myf errortype, int errarg);
|
2006-04-06 15:49:00 +02:00
|
|
|
static int open_binary_frm(THD *thd, TABLE_SHARE *share,
|
|
|
|
|
uchar *head, File file);
|
2000-07-31 21:29:14 +02:00
|
|
|
static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,
|
|
|
|
|
uint types, char **names);
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
static uint find_field(Field **fields, uchar *record, uint start, uint length);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
WL#3984 (Revise locking of mysql.general_log and mysql.slow_log)
Bug#25422 (Hang with log tables)
Bug 17876 (Truncating mysql.slow_log in a SP after using cursor locks the
thread)
Bug 23044 (Warnings on flush of a log table)
Bug 29129 (Resetting general_log while the GLOBAL READ LOCK is set causes
a deadlock)
Prior to this fix, the server would hang when performing concurrent
ALTER TABLE or TRUNCATE TABLE statements against the LOG TABLES,
which are mysql.general_log and mysql.slow_log.
The root cause traces to the following code:
in sql_base.cc, open_table()
if (table->in_use != thd)
{
/* wait_for_condition will unlock LOCK_open for us */
wait_for_condition(thd, &LOCK_open, &COND_refresh);
}
The problem with this code is that the current implementation of the
LOGGER creates 'fake' THD objects, like
- Log_to_csv_event_handler::general_log_thd
- Log_to_csv_event_handler::slow_log_thd
which are not associated to a real thread running in the server,
so that waiting for these non-existing threads to release table locks
cause the dead lock.
In general, the design of Log_to_csv_event_handler does not fit into the
general architecture of the server, so that the concept of general_log_thd
and slow_log_thd has to be abandoned:
- this implementation does not work with table locking
- it will not work with commands like SHOW PROCESSLIST
- having the log tables always opened does not integrate well with DDL
operations / FLUSH TABLES / SET GLOBAL READ_ONLY
With this patch, the fundamental design of the LOGGER has been changed to:
- always open and close a log table when writing a log
- remove totally the usage of fake THD objects
- clarify how locking of log tables is implemented in general.
See WL#3984 for details related to the new locking design.
Additional changes (misc bugs exposed and fixed):
1)
mysqldump which would ignore some tables in dump_all_tables_in_db(),
but forget to ignore the same in dump_all_views_in_db().
2)
mysqldump would also issue an empty "LOCK TABLE" command when all the tables
to lock are to be ignored (numrows == 0), instead of not issuing the query.
3)
Internal errors handlers could intercept errors but not warnings
(see sql_error.cc).
4)
Implementing a nested call to open tables, for the performance schema tables,
exposed an existing bug in remove_table_from_cache(), which would perform:
in_use->some_tables_deleted=1;
against another thread, without any consideration about thread locking.
This call inside remove_table_from_cache() was not required anyway,
since calling mysql_lock_abort() takes care of aborting -- cleanly -- threads
that might hold a lock on a table.
This line (in_use->some_tables_deleted=1) has been removed.
2007-07-27 08:31:06 +02:00
|
|
|
inline bool is_system_table_name(const char *name, uint length);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
/**************************************************************************
|
|
|
|
|
Object_creation_ctx implementation.
|
|
|
|
|
**************************************************************************/
|
|
|
|
|
|
|
|
|
|
Object_creation_ctx *Object_creation_ctx::set_n_backup(THD *thd)
|
|
|
|
|
{
|
2007-08-13 15:11:25 +02:00
|
|
|
Object_creation_ctx *backup_ctx;
|
|
|
|
|
DBUG_ENTER("Object_creation_ctx::set_n_backup");
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
|
2007-08-13 15:11:25 +02:00
|
|
|
backup_ctx= create_backup_ctx(thd);
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
change_env(thd);
|
|
|
|
|
|
2007-08-13 15:11:25 +02:00
|
|
|
DBUG_RETURN(backup_ctx);
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Object_creation_ctx::restore_env(THD *thd, Object_creation_ctx *backup_ctx)
|
|
|
|
|
{
|
|
|
|
|
if (!backup_ctx)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
backup_ctx->change_env(thd);
|
|
|
|
|
|
|
|
|
|
delete backup_ctx;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**************************************************************************
|
|
|
|
|
Default_object_creation_ctx implementation.
|
|
|
|
|
**************************************************************************/
|
|
|
|
|
|
|
|
|
|
Default_object_creation_ctx::Default_object_creation_ctx(THD *thd)
|
|
|
|
|
: m_client_cs(thd->variables.character_set_client),
|
|
|
|
|
m_connection_cl(thd->variables.collation_connection)
|
|
|
|
|
{ }
|
|
|
|
|
|
|
|
|
|
Default_object_creation_ctx::Default_object_creation_ctx(
|
|
|
|
|
CHARSET_INFO *client_cs, CHARSET_INFO *connection_cl)
|
|
|
|
|
: m_client_cs(client_cs),
|
|
|
|
|
m_connection_cl(connection_cl)
|
|
|
|
|
{ }
|
|
|
|
|
|
|
|
|
|
Object_creation_ctx *
|
2007-08-13 15:11:25 +02:00
|
|
|
Default_object_creation_ctx::create_backup_ctx(THD *thd) const
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
{
|
|
|
|
|
return new Default_object_creation_ctx(thd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Default_object_creation_ctx::change_env(THD *thd) const
|
|
|
|
|
{
|
|
|
|
|
thd->variables.character_set_client= m_client_cs;
|
|
|
|
|
thd->variables.collation_connection= m_connection_cl;
|
|
|
|
|
|
|
|
|
|
thd->update_charset();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**************************************************************************
|
|
|
|
|
View_creation_ctx implementation.
|
|
|
|
|
**************************************************************************/
|
|
|
|
|
|
|
|
|
|
View_creation_ctx *View_creation_ctx::create(THD *thd)
|
|
|
|
|
{
|
|
|
|
|
View_creation_ctx *ctx= new (thd->mem_root) View_creation_ctx(thd);
|
|
|
|
|
|
|
|
|
|
return ctx;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
|
|
|
|
|
View_creation_ctx * View_creation_ctx::create(THD *thd,
|
2007-07-16 22:59:21 +02:00
|
|
|
TABLE_LIST *view)
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
{
|
|
|
|
|
View_creation_ctx *ctx= new (thd->mem_root) View_creation_ctx(thd);
|
|
|
|
|
|
|
|
|
|
/* Throw a warning if there is NULL cs name. */
|
|
|
|
|
|
|
|
|
|
if (!view->view_client_cs_name.str ||
|
|
|
|
|
!view->view_connection_cl_name.str)
|
|
|
|
|
{
|
|
|
|
|
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
|
|
|
|
|
ER_VIEW_NO_CREATION_CTX,
|
|
|
|
|
ER(ER_VIEW_NO_CREATION_CTX),
|
|
|
|
|
(const char *) view->db,
|
|
|
|
|
(const char *) view->table_name);
|
|
|
|
|
|
|
|
|
|
ctx->m_client_cs= system_charset_info;
|
|
|
|
|
ctx->m_connection_cl= system_charset_info;
|
|
|
|
|
|
|
|
|
|
return ctx;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Resolve cs names. Throw a warning if there is unknown cs name. */
|
|
|
|
|
|
|
|
|
|
bool invalid_creation_ctx;
|
|
|
|
|
|
|
|
|
|
invalid_creation_ctx= resolve_charset(view->view_client_cs_name.str,
|
|
|
|
|
system_charset_info,
|
|
|
|
|
&ctx->m_client_cs);
|
|
|
|
|
|
|
|
|
|
invalid_creation_ctx= resolve_collation(view->view_connection_cl_name.str,
|
|
|
|
|
system_charset_info,
|
|
|
|
|
&ctx->m_connection_cl) ||
|
|
|
|
|
invalid_creation_ctx;
|
|
|
|
|
|
|
|
|
|
if (invalid_creation_ctx)
|
|
|
|
|
{
|
|
|
|
|
sql_print_warning("View '%s'.'%s': there is unknown charset/collation "
|
|
|
|
|
"names (client: '%s'; connection: '%s').",
|
|
|
|
|
(const char *) view->db,
|
|
|
|
|
(const char *) view->table_name,
|
|
|
|
|
(const char *) view->view_client_cs_name.str,
|
|
|
|
|
(const char *) view->view_connection_cl_name.str);
|
|
|
|
|
|
|
|
|
|
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
|
|
|
|
|
ER_VIEW_INVALID_CREATION_CTX,
|
|
|
|
|
ER(ER_VIEW_INVALID_CREATION_CTX),
|
|
|
|
|
(const char *) view->db,
|
|
|
|
|
(const char *) view->table_name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ctx;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
/* Get column name from column hash */
|
|
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
static uchar *get_field_name(Field **buff, size_t *length,
|
|
|
|
|
my_bool not_used __attribute__((unused)))
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2004-03-28 01:11:54 +01:00
|
|
|
*length= (uint) strlen((*buff)->field_name);
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
return (uchar*) (*buff)->field_name;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
|
2005-12-31 06:01:26 +01:00
|
|
|
/*
|
|
|
|
|
Returns pointer to '.frm' extension of the file name.
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
fn_rext()
|
|
|
|
|
name file name
|
|
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Checks file name part starting with the rightmost '.' character,
|
|
|
|
|
and returns it if it is equal to '.frm'.
|
|
|
|
|
|
|
|
|
|
TODO
|
|
|
|
|
It is a good idea to get rid of this function modifying the code
|
|
|
|
|
to garantee that the functions presently calling fn_rext() always
|
|
|
|
|
get arguments in the same format: either with '.frm' or without '.frm'.
|
|
|
|
|
|
|
|
|
|
RETURN VALUES
|
|
|
|
|
Pointer to the '.frm' extension. If there is no extension,
|
|
|
|
|
or extension is not '.frm', pointer at the end of file name.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
char *fn_rext(char *name)
|
|
|
|
|
{
|
|
|
|
|
char *res= strrchr(name, '.');
|
2006-08-02 17:57:06 +02:00
|
|
|
if (res && !strcmp(res, reg_ext))
|
2005-12-31 06:01:26 +01:00
|
|
|
return res;
|
|
|
|
|
return name + strlen(name);
|
|
|
|
|
}
|
|
|
|
|
|
WL#3984 (Revise locking of mysql.general_log and mysql.slow_log)
Bug#25422 (Hang with log tables)
Bug 17876 (Truncating mysql.slow_log in a SP after using cursor locks the
thread)
Bug 23044 (Warnings on flush of a log table)
Bug 29129 (Resetting general_log while the GLOBAL READ LOCK is set causes
a deadlock)
Prior to this fix, the server would hang when performing concurrent
ALTER TABLE or TRUNCATE TABLE statements against the LOG TABLES,
which are mysql.general_log and mysql.slow_log.
The root cause traces to the following code:
in sql_base.cc, open_table()
if (table->in_use != thd)
{
/* wait_for_condition will unlock LOCK_open for us */
wait_for_condition(thd, &LOCK_open, &COND_refresh);
}
The problem with this code is that the current implementation of the
LOGGER creates 'fake' THD objects, like
- Log_to_csv_event_handler::general_log_thd
- Log_to_csv_event_handler::slow_log_thd
which are not associated to a real thread running in the server,
so that waiting for these non-existing threads to release table locks
cause the dead lock.
In general, the design of Log_to_csv_event_handler does not fit into the
general architecture of the server, so that the concept of general_log_thd
and slow_log_thd has to be abandoned:
- this implementation does not work with table locking
- it will not work with commands like SHOW PROCESSLIST
- having the log tables always opened does not integrate well with DDL
operations / FLUSH TABLES / SET GLOBAL READ_ONLY
With this patch, the fundamental design of the LOGGER has been changed to:
- always open and close a log table when writing a log
- remove totally the usage of fake THD objects
- clarify how locking of log tables is implemented in general.
See WL#3984 for details related to the new locking design.
Additional changes (misc bugs exposed and fixed):
1)
mysqldump which would ignore some tables in dump_all_tables_in_db(),
but forget to ignore the same in dump_all_views_in_db().
2)
mysqldump would also issue an empty "LOCK TABLE" command when all the tables
to lock are to be ignored (numrows == 0), instead of not issuing the query.
3)
Internal errors handlers could intercept errors but not warnings
(see sql_error.cc).
4)
Implementing a nested call to open tables, for the performance schema tables,
exposed an existing bug in remove_table_from_cache(), which would perform:
in_use->some_tables_deleted=1;
against another thread, without any consideration about thread locking.
This call inside remove_table_from_cache() was not required anyway,
since calling mysql_lock_abort() takes care of aborting -- cleanly -- threads
that might hold a lock on a table.
This line (in_use->some_tables_deleted=1) has been removed.
2007-07-27 08:31:06 +02:00
|
|
|
TABLE_CATEGORY get_table_category(const LEX_STRING *db, const LEX_STRING *name)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(db != NULL);
|
|
|
|
|
DBUG_ASSERT(name != NULL);
|
|
|
|
|
|
|
|
|
|
if ((db->length == INFORMATION_SCHEMA_NAME.length) &&
|
|
|
|
|
(my_strcasecmp(system_charset_info,
|
|
|
|
|
INFORMATION_SCHEMA_NAME.str,
|
|
|
|
|
db->str) == 0))
|
|
|
|
|
{
|
|
|
|
|
return TABLE_CATEGORY_INFORMATION;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((db->length == MYSQL_SCHEMA_NAME.length) &&
|
|
|
|
|
(my_strcasecmp(system_charset_info,
|
|
|
|
|
MYSQL_SCHEMA_NAME.str,
|
|
|
|
|
db->str) == 0))
|
|
|
|
|
{
|
|
|
|
|
if (is_system_table_name(name->str, name->length))
|
|
|
|
|
{
|
|
|
|
|
return TABLE_CATEGORY_SYSTEM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((name->length == GENERAL_LOG_NAME.length) &&
|
|
|
|
|
(my_strcasecmp(system_charset_info,
|
|
|
|
|
GENERAL_LOG_NAME.str,
|
|
|
|
|
name->str) == 0))
|
|
|
|
|
{
|
|
|
|
|
return TABLE_CATEGORY_PERFORMANCE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((name->length == SLOW_LOG_NAME.length) &&
|
|
|
|
|
(my_strcasecmp(system_charset_info,
|
|
|
|
|
SLOW_LOG_NAME.str,
|
|
|
|
|
name->str) == 0))
|
|
|
|
|
{
|
|
|
|
|
return TABLE_CATEGORY_PERFORMANCE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return TABLE_CATEGORY_USER;
|
|
|
|
|
}
|
|
|
|
|
|
2005-12-31 06:01:26 +01:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
/*
|
|
|
|
|
Allocate a setup TABLE_SHARE structure
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
alloc_table_share()
|
|
|
|
|
TABLE_LIST Take database and table name from there
|
|
|
|
|
key Table cache key (db \0 table_name \0...)
|
|
|
|
|
key_length Length of key
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
0 Error (out of memory)
|
|
|
|
|
# Share
|
|
|
|
|
*/
|
|
|
|
|
|
2005-11-29 09:07:21 +01:00
|
|
|
TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key,
|
2005-11-23 21:45:02 +01:00
|
|
|
uint key_length)
|
|
|
|
|
{
|
|
|
|
|
MEM_ROOT mem_root;
|
|
|
|
|
TABLE_SHARE *share;
|
2006-08-21 17:02:11 +02:00
|
|
|
char *key_buff, *path_buff;
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
char path[FN_REFLEN];
|
|
|
|
|
uint path_length;
|
2006-08-02 17:57:06 +02:00
|
|
|
DBUG_ENTER("alloc_table_share");
|
|
|
|
|
DBUG_PRINT("enter", ("table: '%s'.'%s'",
|
|
|
|
|
table_list->db, table_list->table_name));
|
2005-11-23 21:45:02 +01:00
|
|
|
|
2005-12-31 06:01:26 +01:00
|
|
|
path_length= build_table_filename(path, sizeof(path) - 1,
|
|
|
|
|
table_list->db,
|
2006-08-02 17:57:06 +02:00
|
|
|
table_list->table_name, "", 0);
|
2005-11-23 21:45:02 +01:00
|
|
|
init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
|
2006-08-21 17:02:11 +02:00
|
|
|
if (multi_alloc_root(&mem_root,
|
|
|
|
|
&share, sizeof(*share),
|
|
|
|
|
&key_buff, key_length,
|
|
|
|
|
&path_buff, path_length + 1,
|
|
|
|
|
NULL))
|
2005-11-23 21:45:02 +01:00
|
|
|
{
|
|
|
|
|
bzero((char*) share, sizeof(*share));
|
|
|
|
|
|
2006-08-21 17:02:11 +02:00
|
|
|
share->set_table_cache_key(key_buff, key, key_length);
|
2005-11-23 21:45:02 +01:00
|
|
|
|
2006-08-21 17:02:11 +02:00
|
|
|
share->path.str= path_buff;
|
2005-11-23 21:45:02 +01:00
|
|
|
share->path.length= path_length;
|
|
|
|
|
strmov(share->path.str, path);
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
share->normalized_path.str= share->path.str;
|
|
|
|
|
share->normalized_path.length= path_length;
|
2005-11-23 21:45:02 +01:00
|
|
|
|
|
|
|
|
share->version= refresh_version;
|
|
|
|
|
|
2006-02-23 13:34:03 +01:00
|
|
|
/*
|
|
|
|
|
This constant is used to mark that no table map version has been
|
|
|
|
|
assigned. No arithmetic is done on the value: it will be
|
|
|
|
|
overwritten with a value taken from MYSQL_BIN_LOG.
|
|
|
|
|
*/
|
|
|
|
|
share->table_map_version= ~(ulonglong)0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Since alloc_table_share() can be called without any locking (for
|
|
|
|
|
example, ha_create_table... functions), we do not assign a table
|
|
|
|
|
map id here. Instead we assign a value that is not used
|
|
|
|
|
elsewhere, and then assign a table map id inside open_table()
|
|
|
|
|
under the protection of the LOCK_open mutex.
|
|
|
|
|
*/
|
2006-03-09 03:56:14 +01:00
|
|
|
share->table_map_id= ~0UL;
|
2006-03-17 18:11:07 +01:00
|
|
|
share->cached_row_logging_check= -1;
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root));
|
|
|
|
|
pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
|
|
|
|
|
pthread_cond_init(&share->cond, NULL);
|
|
|
|
|
}
|
2006-08-02 17:57:06 +02:00
|
|
|
DBUG_RETURN(share);
|
2005-11-23 21:45:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Initialize share for temporary tables
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
init_tmp_table_share()
|
Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
corrupts a MERGE table
Bug 26867 - LOCK TABLES + REPAIR + merge table result in
memory/cpu hogging
Bug 26377 - Deadlock with MERGE and FLUSH TABLE
Bug 25038 - Waiting TRUNCATE
Bug 25700 - merge base tables get corrupted by
optimize/analyze/repair table
Bug 30275 - Merge tables: flush tables or unlock tables
causes server to crash
Bug 19627 - temporary merge table locking
Bug 27660 - Falcon: merge table possible
Bug 30273 - merge tables: Can't lock file (errno: 155)
The problems were:
Bug 26379 - Combination of FLUSH TABLE and REPAIR TABLE
corrupts a MERGE table
1. A thread trying to lock a MERGE table performs busy waiting while
REPAIR TABLE or a similar table administration task is ongoing on
one or more of its MyISAM tables.
2. A thread trying to lock a MERGE table performs busy waiting until all
threads that did REPAIR TABLE or similar table administration tasks
on one or more of its MyISAM tables in LOCK TABLES segments do UNLOCK
TABLES. The difference against problem #1 is that the busy waiting
takes place *after* the administration task. It is terminated by
UNLOCK TABLES only.
3. Two FLUSH TABLES within a LOCK TABLES segment can invalidate the
lock. This does *not* require a MERGE table. The first FLUSH TABLES
can be replaced by any statement that requires other threads to
reopen the table. In 5.0 and 5.1 a single FLUSH TABLES can provoke
the problem.
Bug 26867 - LOCK TABLES + REPAIR + merge table result in
memory/cpu hogging
Trying DML on a MERGE table, which has a child locked and
repaired by another thread, made an infinite loop in the server.
Bug 26377 - Deadlock with MERGE and FLUSH TABLE
Locking a MERGE table and its children in parent-child order
and flushing the child deadlocked the server.
Bug 25038 - Waiting TRUNCATE
Truncating a MERGE child, while the MERGE table was in use,
let the truncate fail instead of waiting for the table to
become free.
Bug 25700 - merge base tables get corrupted by
optimize/analyze/repair table
Repairing a child of an open MERGE table corrupted the child.
It was necessary to FLUSH the child first.
Bug 30275 - Merge tables: flush tables or unlock tables
causes server to crash
Flushing and optimizing locked MERGE children crashed the server.
Bug 19627 - temporary merge table locking
Use of a temporary MERGE table with non-temporary children
could corrupt the children.
Temporary tables are never locked. So we do now prohibit
non-temporary chidlren of a temporary MERGE table.
Bug 27660 - Falcon: merge table possible
It was possible to create a MERGE table with non-MyISAM children.
Bug 30273 - merge tables: Can't lock file (errno: 155)
This was a Windows-only bug. Table administration statements
sometimes failed with "Can't lock file (errno: 155)".
These bugs are fixed by a new implementation of MERGE table open.
When opening a MERGE table in open_tables() we do now add the
child tables to the list of tables to be opened by open_tables()
(the "query_list"). The children are not opened in the handler at
this stage.
After opening the parent, open_tables() opens each child from the
now extended query_list. When the last child is opened, we remove
the children from the query_list again and attach the children to
the parent. This behaves similar to the old open. However it does
not open the MyISAM tables directly, but grabs them from the already
open children.
When closing a MERGE table in close_thread_table() we detach the
children only. Closing of the children is done implicitly because
they are in thd->open_tables.
For more detail see the comment at the top of ha_myisammrg.cc.
Changed from open_ltable() to open_and_lock_tables() in all places
that can be relevant for MERGE tables. The latter can handle tables
added to the list on the fly. When open_ltable() was used in a loop
over a list of tables, the list must be temporarily terminated
after every table for open_and_lock_tables().
table_list->required_type is set to FRMTYPE_TABLE to avoid open of
special tables. Handling of derived tables is suppressed.
These details are handled by the new function
open_n_lock_single_table(), which has nearly the same signature as
open_ltable() and can replace it in most cases.
In reopen_tables() some of the tables open by a thread can be
closed and reopened. When a MERGE child is affected, the parent
must be closed and reopened too. Closing of the parent is forced
before the first child is closed. Reopen happens in the order of
thd->open_tables. MERGE parents do not attach their children
automatically at open. This is done after all tables are reopened.
So all children are open when attaching them.
Special lock handling like mysql_lock_abort() or mysql_lock_remove()
needs to be suppressed for MERGE children or forwarded to the parent.
This depends on the situation. In loops over all open tables one
suppresses child lock handling. When a single table is touched,
forwarding is done.
Behavioral changes:
===================
This patch changes the behavior of temporary MERGE tables.
Temporary MERGE must have temporary children.
The old behavior was wrong. A temporary table is not locked. Hence
even non-temporary children were not locked. See
Bug 19627 - temporary merge table locking.
You cannot change the union list of a non-temporary MERGE table
when LOCK TABLES is in effect. The following does *not* work:
CREATE TABLE m1 ... ENGINE=MRG_MYISAM ...;
LOCK TABLES t1 WRITE, t2 WRITE, m1 WRITE;
ALTER TABLE m1 ... UNION=(t1,t2) ...;
However, you can do this with a temporary MERGE table.
You cannot create a MERGE table with CREATE ... SELECT, neither
as a temporary MERGE table, nor as a non-temporary MERGE table.
CREATE TABLE m1 ... ENGINE=MRG_MYISAM ... SELECT ...;
Gives error message: table is not BASE TABLE.
2007-11-15 20:25:43 +01:00
|
|
|
thd thread handle
|
2005-11-23 21:45:02 +01:00
|
|
|
share Share to fill
|
|
|
|
|
key Table_cache_key, as generated from create_table_def_key.
|
|
|
|
|
must start with db name.
|
|
|
|
|
key_length Length of key
|
|
|
|
|
table_name Table name
|
|
|
|
|
path Path to file (possible in lower case) without .frm
|
|
|
|
|
|
|
|
|
|
NOTES
|
|
|
|
|
This is different from alloc_table_share() because temporary tables
|
|
|
|
|
don't have to be shared between threads or put into the table def
|
|
|
|
|
cache, so we can do some things notable simpler and faster
|
|
|
|
|
|
|
|
|
|
If table is not put in thd->temporary_tables (happens only when
|
|
|
|
|
one uses OPEN TEMPORARY) then one can specify 'db' as key and
|
|
|
|
|
use key_length= 0 as neither table_cache_key or key_length will be used).
|
|
|
|
|
*/
|
|
|
|
|
|
Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
corrupts a MERGE table
Bug 26867 - LOCK TABLES + REPAIR + merge table result in
memory/cpu hogging
Bug 26377 - Deadlock with MERGE and FLUSH TABLE
Bug 25038 - Waiting TRUNCATE
Bug 25700 - merge base tables get corrupted by
optimize/analyze/repair table
Bug 30275 - Merge tables: flush tables or unlock tables
causes server to crash
Bug 19627 - temporary merge table locking
Bug 27660 - Falcon: merge table possible
Bug 30273 - merge tables: Can't lock file (errno: 155)
The problems were:
Bug 26379 - Combination of FLUSH TABLE and REPAIR TABLE
corrupts a MERGE table
1. A thread trying to lock a MERGE table performs busy waiting while
REPAIR TABLE or a similar table administration task is ongoing on
one or more of its MyISAM tables.
2. A thread trying to lock a MERGE table performs busy waiting until all
threads that did REPAIR TABLE or similar table administration tasks
on one or more of its MyISAM tables in LOCK TABLES segments do UNLOCK
TABLES. The difference against problem #1 is that the busy waiting
takes place *after* the administration task. It is terminated by
UNLOCK TABLES only.
3. Two FLUSH TABLES within a LOCK TABLES segment can invalidate the
lock. This does *not* require a MERGE table. The first FLUSH TABLES
can be replaced by any statement that requires other threads to
reopen the table. In 5.0 and 5.1 a single FLUSH TABLES can provoke
the problem.
Bug 26867 - LOCK TABLES + REPAIR + merge table result in
memory/cpu hogging
Trying DML on a MERGE table, which has a child locked and
repaired by another thread, made an infinite loop in the server.
Bug 26377 - Deadlock with MERGE and FLUSH TABLE
Locking a MERGE table and its children in parent-child order
and flushing the child deadlocked the server.
Bug 25038 - Waiting TRUNCATE
Truncating a MERGE child, while the MERGE table was in use,
let the truncate fail instead of waiting for the table to
become free.
Bug 25700 - merge base tables get corrupted by
optimize/analyze/repair table
Repairing a child of an open MERGE table corrupted the child.
It was necessary to FLUSH the child first.
Bug 30275 - Merge tables: flush tables or unlock tables
causes server to crash
Flushing and optimizing locked MERGE children crashed the server.
Bug 19627 - temporary merge table locking
Use of a temporary MERGE table with non-temporary children
could corrupt the children.
Temporary tables are never locked. So we do now prohibit
non-temporary chidlren of a temporary MERGE table.
Bug 27660 - Falcon: merge table possible
It was possible to create a MERGE table with non-MyISAM children.
Bug 30273 - merge tables: Can't lock file (errno: 155)
This was a Windows-only bug. Table administration statements
sometimes failed with "Can't lock file (errno: 155)".
These bugs are fixed by a new implementation of MERGE table open.
When opening a MERGE table in open_tables() we do now add the
child tables to the list of tables to be opened by open_tables()
(the "query_list"). The children are not opened in the handler at
this stage.
After opening the parent, open_tables() opens each child from the
now extended query_list. When the last child is opened, we remove
the children from the query_list again and attach the children to
the parent. This behaves similar to the old open. However it does
not open the MyISAM tables directly, but grabs them from the already
open children.
When closing a MERGE table in close_thread_table() we detach the
children only. Closing of the children is done implicitly because
they are in thd->open_tables.
For more detail see the comment at the top of ha_myisammrg.cc.
Changed from open_ltable() to open_and_lock_tables() in all places
that can be relevant for MERGE tables. The latter can handle tables
added to the list on the fly. When open_ltable() was used in a loop
over a list of tables, the list must be temporarily terminated
after every table for open_and_lock_tables().
table_list->required_type is set to FRMTYPE_TABLE to avoid open of
special tables. Handling of derived tables is suppressed.
These details are handled by the new function
open_n_lock_single_table(), which has nearly the same signature as
open_ltable() and can replace it in most cases.
In reopen_tables() some of the tables open by a thread can be
closed and reopened. When a MERGE child is affected, the parent
must be closed and reopened too. Closing of the parent is forced
before the first child is closed. Reopen happens in the order of
thd->open_tables. MERGE parents do not attach their children
automatically at open. This is done after all tables are reopened.
So all children are open when attaching them.
Special lock handling like mysql_lock_abort() or mysql_lock_remove()
needs to be suppressed for MERGE children or forwarded to the parent.
This depends on the situation. In loops over all open tables one
suppresses child lock handling. When a single table is touched,
forwarding is done.
Behavioral changes:
===================
This patch changes the behavior of temporary MERGE tables.
Temporary MERGE must have temporary children.
The old behavior was wrong. A temporary table is not locked. Hence
even non-temporary children were not locked. See
Bug 19627 - temporary merge table locking.
You cannot change the union list of a non-temporary MERGE table
when LOCK TABLES is in effect. The following does *not* work:
CREATE TABLE m1 ... ENGINE=MRG_MYISAM ...;
LOCK TABLES t1 WRITE, t2 WRITE, m1 WRITE;
ALTER TABLE m1 ... UNION=(t1,t2) ...;
However, you can do this with a temporary MERGE table.
You cannot create a MERGE table with CREATE ... SELECT, neither
as a temporary MERGE table, nor as a non-temporary MERGE table.
CREATE TABLE m1 ... ENGINE=MRG_MYISAM ... SELECT ...;
Gives error message: table is not BASE TABLE.
2007-11-15 20:25:43 +01:00
|
|
|
void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key,
|
2005-11-23 21:45:02 +01:00
|
|
|
uint key_length, const char *table_name,
|
|
|
|
|
const char *path)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ENTER("init_tmp_table_share");
|
2006-08-02 17:57:06 +02:00
|
|
|
DBUG_PRINT("enter", ("table: '%s'.'%s'", key, table_name));
|
2005-11-23 21:45:02 +01:00
|
|
|
|
|
|
|
|
bzero((char*) share, sizeof(*share));
|
|
|
|
|
init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
|
WL#3984 (Revise locking of mysql.general_log and mysql.slow_log)
Bug#25422 (Hang with log tables)
Bug 17876 (Truncating mysql.slow_log in a SP after using cursor locks the
thread)
Bug 23044 (Warnings on flush of a log table)
Bug 29129 (Resetting general_log while the GLOBAL READ LOCK is set causes
a deadlock)
Prior to this fix, the server would hang when performing concurrent
ALTER TABLE or TRUNCATE TABLE statements against the LOG TABLES,
which are mysql.general_log and mysql.slow_log.
The root cause traces to the following code:
in sql_base.cc, open_table()
if (table->in_use != thd)
{
/* wait_for_condition will unlock LOCK_open for us */
wait_for_condition(thd, &LOCK_open, &COND_refresh);
}
The problem with this code is that the current implementation of the
LOGGER creates 'fake' THD objects, like
- Log_to_csv_event_handler::general_log_thd
- Log_to_csv_event_handler::slow_log_thd
which are not associated to a real thread running in the server,
so that waiting for these non-existing threads to release table locks
cause the dead lock.
In general, the design of Log_to_csv_event_handler does not fit into the
general architecture of the server, so that the concept of general_log_thd
and slow_log_thd has to be abandoned:
- this implementation does not work with table locking
- it will not work with commands like SHOW PROCESSLIST
- having the log tables always opened does not integrate well with DDL
operations / FLUSH TABLES / SET GLOBAL READ_ONLY
With this patch, the fundamental design of the LOGGER has been changed to:
- always open and close a log table when writing a log
- remove totally the usage of fake THD objects
- clarify how locking of log tables is implemented in general.
See WL#3984 for details related to the new locking design.
Additional changes (misc bugs exposed and fixed):
1)
mysqldump which would ignore some tables in dump_all_tables_in_db(),
but forget to ignore the same in dump_all_views_in_db().
2)
mysqldump would also issue an empty "LOCK TABLE" command when all the tables
to lock are to be ignored (numrows == 0), instead of not issuing the query.
3)
Internal errors handlers could intercept errors but not warnings
(see sql_error.cc).
4)
Implementing a nested call to open tables, for the performance schema tables,
exposed an existing bug in remove_table_from_cache(), which would perform:
in_use->some_tables_deleted=1;
against another thread, without any consideration about thread locking.
This call inside remove_table_from_cache() was not required anyway,
since calling mysql_lock_abort() takes care of aborting -- cleanly -- threads
that might hold a lock on a table.
This line (in_use->some_tables_deleted=1) has been removed.
2007-07-27 08:31:06 +02:00
|
|
|
share->table_category= TABLE_CATEGORY_TEMPORARY;
|
|
|
|
|
share->tmp_table= INTERNAL_TMP_TABLE;
|
2005-11-23 21:45:02 +01:00
|
|
|
share->db.str= (char*) key;
|
|
|
|
|
share->db.length= strlen(key);
|
|
|
|
|
share->table_cache_key.str= (char*) key;
|
|
|
|
|
share->table_cache_key.length= key_length;
|
|
|
|
|
share->table_name.str= (char*) table_name;
|
|
|
|
|
share->table_name.length= strlen(table_name);
|
|
|
|
|
share->path.str= (char*) path;
|
|
|
|
|
share->normalized_path.str= (char*) path;
|
|
|
|
|
share->path.length= share->normalized_path.length= strlen(path);
|
|
|
|
|
share->frm_version= FRM_VER_TRUE_VARCHAR;
|
|
|
|
|
|
2006-02-23 13:34:03 +01:00
|
|
|
/*
|
|
|
|
|
Temporary tables are not replicated, but we set up these fields
|
|
|
|
|
anyway to be able to catch errors.
|
|
|
|
|
*/
|
|
|
|
|
share->table_map_version= ~(ulonglong)0;
|
2006-03-17 18:11:07 +01:00
|
|
|
share->cached_row_logging_check= -1;
|
2006-02-23 13:34:03 +01:00
|
|
|
|
Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
corrupts a MERGE table
Bug 26867 - LOCK TABLES + REPAIR + merge table result in
memory/cpu hogging
Bug 26377 - Deadlock with MERGE and FLUSH TABLE
Bug 25038 - Waiting TRUNCATE
Bug 25700 - merge base tables get corrupted by
optimize/analyze/repair table
Bug 30275 - Merge tables: flush tables or unlock tables
causes server to crash
Bug 19627 - temporary merge table locking
Bug 27660 - Falcon: merge table possible
Bug 30273 - merge tables: Can't lock file (errno: 155)
The problems were:
Bug 26379 - Combination of FLUSH TABLE and REPAIR TABLE
corrupts a MERGE table
1. A thread trying to lock a MERGE table performs busy waiting while
REPAIR TABLE or a similar table administration task is ongoing on
one or more of its MyISAM tables.
2. A thread trying to lock a MERGE table performs busy waiting until all
threads that did REPAIR TABLE or similar table administration tasks
on one or more of its MyISAM tables in LOCK TABLES segments do UNLOCK
TABLES. The difference against problem #1 is that the busy waiting
takes place *after* the administration task. It is terminated by
UNLOCK TABLES only.
3. Two FLUSH TABLES within a LOCK TABLES segment can invalidate the
lock. This does *not* require a MERGE table. The first FLUSH TABLES
can be replaced by any statement that requires other threads to
reopen the table. In 5.0 and 5.1 a single FLUSH TABLES can provoke
the problem.
Bug 26867 - LOCK TABLES + REPAIR + merge table result in
memory/cpu hogging
Trying DML on a MERGE table, which has a child locked and
repaired by another thread, made an infinite loop in the server.
Bug 26377 - Deadlock with MERGE and FLUSH TABLE
Locking a MERGE table and its children in parent-child order
and flushing the child deadlocked the server.
Bug 25038 - Waiting TRUNCATE
Truncating a MERGE child, while the MERGE table was in use,
let the truncate fail instead of waiting for the table to
become free.
Bug 25700 - merge base tables get corrupted by
optimize/analyze/repair table
Repairing a child of an open MERGE table corrupted the child.
It was necessary to FLUSH the child first.
Bug 30275 - Merge tables: flush tables or unlock tables
causes server to crash
Flushing and optimizing locked MERGE children crashed the server.
Bug 19627 - temporary merge table locking
Use of a temporary MERGE table with non-temporary children
could corrupt the children.
Temporary tables are never locked. So we do now prohibit
non-temporary chidlren of a temporary MERGE table.
Bug 27660 - Falcon: merge table possible
It was possible to create a MERGE table with non-MyISAM children.
Bug 30273 - merge tables: Can't lock file (errno: 155)
This was a Windows-only bug. Table administration statements
sometimes failed with "Can't lock file (errno: 155)".
These bugs are fixed by a new implementation of MERGE table open.
When opening a MERGE table in open_tables() we do now add the
child tables to the list of tables to be opened by open_tables()
(the "query_list"). The children are not opened in the handler at
this stage.
After opening the parent, open_tables() opens each child from the
now extended query_list. When the last child is opened, we remove
the children from the query_list again and attach the children to
the parent. This behaves similar to the old open. However it does
not open the MyISAM tables directly, but grabs them from the already
open children.
When closing a MERGE table in close_thread_table() we detach the
children only. Closing of the children is done implicitly because
they are in thd->open_tables.
For more detail see the comment at the top of ha_myisammrg.cc.
Changed from open_ltable() to open_and_lock_tables() in all places
that can be relevant for MERGE tables. The latter can handle tables
added to the list on the fly. When open_ltable() was used in a loop
over a list of tables, the list must be temporarily terminated
after every table for open_and_lock_tables().
table_list->required_type is set to FRMTYPE_TABLE to avoid open of
special tables. Handling of derived tables is suppressed.
These details are handled by the new function
open_n_lock_single_table(), which has nearly the same signature as
open_ltable() and can replace it in most cases.
In reopen_tables() some of the tables open by a thread can be
closed and reopened. When a MERGE child is affected, the parent
must be closed and reopened too. Closing of the parent is forced
before the first child is closed. Reopen happens in the order of
thd->open_tables. MERGE parents do not attach their children
automatically at open. This is done after all tables are reopened.
So all children are open when attaching them.
Special lock handling like mysql_lock_abort() or mysql_lock_remove()
needs to be suppressed for MERGE children or forwarded to the parent.
This depends on the situation. In loops over all open tables one
suppresses child lock handling. When a single table is touched,
forwarding is done.
Behavioral changes:
===================
This patch changes the behavior of temporary MERGE tables.
Temporary MERGE must have temporary children.
The old behavior was wrong. A temporary table is not locked. Hence
even non-temporary children were not locked. See
Bug 19627 - temporary merge table locking.
You cannot change the union list of a non-temporary MERGE table
when LOCK TABLES is in effect. The following does *not* work:
CREATE TABLE m1 ... ENGINE=MRG_MYISAM ...;
LOCK TABLES t1 WRITE, t2 WRITE, m1 WRITE;
ALTER TABLE m1 ... UNION=(t1,t2) ...;
However, you can do this with a temporary MERGE table.
You cannot create a MERGE table with CREATE ... SELECT, neither
as a temporary MERGE table, nor as a non-temporary MERGE table.
CREATE TABLE m1 ... ENGINE=MRG_MYISAM ... SELECT ...;
Gives error message: table is not BASE TABLE.
2007-11-15 20:25:43 +01:00
|
|
|
/*
|
|
|
|
|
table_map_id is also used for MERGE tables to suppress repeated
|
|
|
|
|
compatibility checks.
|
|
|
|
|
*/
|
|
|
|
|
share->table_map_id= (ulong) thd->query_id;
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
DBUG_VOID_RETURN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-02-12 20:55:37 +01:00
|
|
|
/*
|
2005-11-23 21:45:02 +01:00
|
|
|
Free table share and memory used by it
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
free_table_share()
|
|
|
|
|
share Table share
|
|
|
|
|
|
|
|
|
|
NOTES
|
|
|
|
|
share->mutex must be locked when we come here if it's not a temp table
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void free_table_share(TABLE_SHARE *share)
|
|
|
|
|
{
|
|
|
|
|
MEM_ROOT mem_root;
|
|
|
|
|
DBUG_ENTER("free_table_share");
|
|
|
|
|
DBUG_PRINT("enter", ("table: %s.%s", share->db.str, share->table_name.str));
|
|
|
|
|
DBUG_ASSERT(share->ref_count == 0);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
If someone is waiting for this to be deleted, inform it about this.
|
|
|
|
|
Don't do a delete until we know that no one is refering to this anymore.
|
|
|
|
|
*/
|
|
|
|
|
if (share->tmp_table == NO_TMP_TABLE)
|
|
|
|
|
{
|
|
|
|
|
/* share->mutex is locked in release_table_share() */
|
|
|
|
|
while (share->waiting_on_cond)
|
|
|
|
|
{
|
|
|
|
|
pthread_cond_broadcast(&share->cond);
|
|
|
|
|
pthread_cond_wait(&share->cond, &share->mutex);
|
|
|
|
|
}
|
|
|
|
|
/* No thread refers to this anymore */
|
|
|
|
|
pthread_mutex_unlock(&share->mutex);
|
|
|
|
|
pthread_mutex_destroy(&share->mutex);
|
|
|
|
|
pthread_cond_destroy(&share->cond);
|
|
|
|
|
}
|
|
|
|
|
hash_free(&share->name_hash);
|
2007-03-02 17:43:45 +01:00
|
|
|
|
|
|
|
|
plugin_unlock(NULL, share->db_plugin);
|
|
|
|
|
share->db_plugin= NULL;
|
2005-11-23 21:45:02 +01:00
|
|
|
|
|
|
|
|
/* We must copy mem_root from share because share is allocated through it */
|
|
|
|
|
memcpy((char*) &mem_root, (char*) &share->mem_root, sizeof(mem_root));
|
|
|
|
|
free_root(&mem_root, MYF(0)); // Free's share
|
|
|
|
|
DBUG_VOID_RETURN;
|
|
|
|
|
}
|
2003-02-12 20:55:37 +01:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
|
BUG#9953: CONVERT_TZ requires mysql.time_zone_name to be locked
The problem was that some facilities (like CONVERT_TZ() function or
server HELP statement) may require implicit access to some tables in
'mysql' database. This access was done by ordinary means of adding
such tables to the list of tables the query is going to open.
However, if we issued LOCK TABLES before that, we would get "table
was not locked" error trying to open such implicit tables.
The solution is to treat certain tables as MySQL system tables, like
we already do for mysql.proc. Such tables may be opened for reading
at any moment regardless of any locks in effect. The cost of this is
that system table may be locked for writing only together with other
system tables, it is disallowed to lock system tables for writing and
have any other lock on any other table.
After this patch the following tables are treated as MySQL system
tables:
mysql.help_category
mysql.help_keyword
mysql.help_relation
mysql.help_topic
mysql.proc (it already was)
mysql.time_zone
mysql.time_zone_leap_second
mysql.time_zone_name
mysql.time_zone_transition
mysql.time_zone_transition_type
These tables are now opened with open_system_tables_for_read() and
closed with close_system_tables(), or one table may be opened with
open_system_table_for_update() and closed with close_thread_tables()
(the latter is used for mysql.proc table, which is updated as part of
normal MySQL server operation). These functions may be used when
some tables were opened and locked already.
NOTE: online update of time zone tables is not possible during
replication, because there's no time zone cache flush neither on LOCK
TABLES, nor on FLUSH TABLES, so the master may serve stale time zone
data from cache, while on slave updated data will be loaded from the
time zone tables.
2007-03-09 11:12:31 +01:00
|
|
|
/**
|
|
|
|
|
Return TRUE if a table name matches one of the system table names.
|
|
|
|
|
Currently these are:
|
|
|
|
|
|
|
|
|
|
help_category, help_keyword, help_relation, help_topic,
|
2007-04-05 13:24:34 +02:00
|
|
|
proc, event
|
BUG#9953: CONVERT_TZ requires mysql.time_zone_name to be locked
The problem was that some facilities (like CONVERT_TZ() function or
server HELP statement) may require implicit access to some tables in
'mysql' database. This access was done by ordinary means of adding
such tables to the list of tables the query is going to open.
However, if we issued LOCK TABLES before that, we would get "table
was not locked" error trying to open such implicit tables.
The solution is to treat certain tables as MySQL system tables, like
we already do for mysql.proc. Such tables may be opened for reading
at any moment regardless of any locks in effect. The cost of this is
that system table may be locked for writing only together with other
system tables, it is disallowed to lock system tables for writing and
have any other lock on any other table.
After this patch the following tables are treated as MySQL system
tables:
mysql.help_category
mysql.help_keyword
mysql.help_relation
mysql.help_topic
mysql.proc (it already was)
mysql.time_zone
mysql.time_zone_leap_second
mysql.time_zone_name
mysql.time_zone_transition
mysql.time_zone_transition_type
These tables are now opened with open_system_tables_for_read() and
closed with close_system_tables(), or one table may be opened with
open_system_table_for_update() and closed with close_thread_tables()
(the latter is used for mysql.proc table, which is updated as part of
normal MySQL server operation). These functions may be used when
some tables were opened and locked already.
NOTE: online update of time zone tables is not possible during
replication, because there's no time zone cache flush neither on LOCK
TABLES, nor on FLUSH TABLES, so the master may serve stale time zone
data from cache, while on slave updated data will be loaded from the
time zone tables.
2007-03-09 11:12:31 +01:00
|
|
|
time_zone, time_zone_leap_second, time_zone_name, time_zone_transition,
|
|
|
|
|
time_zone_transition_type
|
|
|
|
|
|
|
|
|
|
This function trades accuracy for speed, so may return false
|
|
|
|
|
positives. Presumably mysql.* database is for internal purposes only
|
|
|
|
|
and should not contain user tables.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
inline bool is_system_table_name(const char *name, uint length)
|
|
|
|
|
{
|
|
|
|
|
CHARSET_INFO *ci= system_charset_info;
|
|
|
|
|
|
|
|
|
|
return (
|
|
|
|
|
/* mysql.proc table */
|
|
|
|
|
length == 4 &&
|
|
|
|
|
my_tolower(ci, name[0]) == 'p' &&
|
|
|
|
|
my_tolower(ci, name[1]) == 'r' &&
|
|
|
|
|
my_tolower(ci, name[2]) == 'o' &&
|
|
|
|
|
my_tolower(ci, name[3]) == 'c' ||
|
|
|
|
|
|
|
|
|
|
length > 4 &&
|
|
|
|
|
(
|
|
|
|
|
/* one of mysql.help* tables */
|
|
|
|
|
my_tolower(ci, name[0]) == 'h' &&
|
|
|
|
|
my_tolower(ci, name[1]) == 'e' &&
|
|
|
|
|
my_tolower(ci, name[2]) == 'l' &&
|
|
|
|
|
my_tolower(ci, name[3]) == 'p' ||
|
|
|
|
|
|
|
|
|
|
/* one of mysql.time_zone* tables */
|
|
|
|
|
my_tolower(ci, name[0]) == 't' &&
|
|
|
|
|
my_tolower(ci, name[1]) == 'i' &&
|
|
|
|
|
my_tolower(ci, name[2]) == 'm' &&
|
2007-04-05 13:24:34 +02:00
|
|
|
my_tolower(ci, name[3]) == 'e' ||
|
|
|
|
|
|
|
|
|
|
/* mysql.event table */
|
|
|
|
|
my_tolower(ci, name[0]) == 'e' &&
|
|
|
|
|
my_tolower(ci, name[1]) == 'v' &&
|
|
|
|
|
my_tolower(ci, name[2]) == 'e' &&
|
|
|
|
|
my_tolower(ci, name[3]) == 'n' &&
|
|
|
|
|
my_tolower(ci, name[4]) == 't'
|
BUG#9953: CONVERT_TZ requires mysql.time_zone_name to be locked
The problem was that some facilities (like CONVERT_TZ() function or
server HELP statement) may require implicit access to some tables in
'mysql' database. This access was done by ordinary means of adding
such tables to the list of tables the query is going to open.
However, if we issued LOCK TABLES before that, we would get "table
was not locked" error trying to open such implicit tables.
The solution is to treat certain tables as MySQL system tables, like
we already do for mysql.proc. Such tables may be opened for reading
at any moment regardless of any locks in effect. The cost of this is
that system table may be locked for writing only together with other
system tables, it is disallowed to lock system tables for writing and
have any other lock on any other table.
After this patch the following tables are treated as MySQL system
tables:
mysql.help_category
mysql.help_keyword
mysql.help_relation
mysql.help_topic
mysql.proc (it already was)
mysql.time_zone
mysql.time_zone_leap_second
mysql.time_zone_name
mysql.time_zone_transition
mysql.time_zone_transition_type
These tables are now opened with open_system_tables_for_read() and
closed with close_system_tables(), or one table may be opened with
open_system_table_for_update() and closed with close_thread_tables()
(the latter is used for mysql.proc table, which is updated as part of
normal MySQL server operation). These functions may be used when
some tables were opened and locked already.
NOTE: online update of time zone tables is not possible during
replication, because there's no time zone cache flush neither on LOCK
TABLES, nor on FLUSH TABLES, so the master may serve stale time zone
data from cache, while on slave updated data will be loaded from the
time zone tables.
2007-03-09 11:12:31 +01:00
|
|
|
)
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
/*
|
|
|
|
|
Read table definition from a binary / text based .frm file
|
|
|
|
|
|
2003-02-12 20:55:37 +01:00
|
|
|
SYNOPSIS
|
2005-11-23 21:45:02 +01:00
|
|
|
open_table_def()
|
|
|
|
|
thd Thread handler
|
|
|
|
|
share Fill this with table definition
|
|
|
|
|
db_flags Bit mask of the following flags: OPEN_VIEW
|
2003-02-12 20:55:37 +01:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
NOTES
|
|
|
|
|
This function is called when the table definition is not cached in
|
|
|
|
|
table_def_cache
|
|
|
|
|
The data is returned in 'share', which is alloced by
|
|
|
|
|
alloc_table_share().. The code assumes that share is initialized.
|
2003-02-12 20:55:37 +01:00
|
|
|
|
|
|
|
|
RETURN VALUES
|
|
|
|
|
0 ok
|
2005-11-23 21:45:02 +01:00
|
|
|
1 Error (see open_table_error)
|
|
|
|
|
2 Error (see open_table_error)
|
2003-02-12 20:55:37 +01:00
|
|
|
3 Wrong data in .frm file
|
2005-11-23 21:45:02 +01:00
|
|
|
4 Error (see open_table_error)
|
|
|
|
|
5 Error (see open_table_error: charset unavailable)
|
2005-05-07 22:57:22 +02:00
|
|
|
6 Unknown .frm version
|
2003-02-12 20:55:37 +01:00
|
|
|
*/
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags)
|
|
|
|
|
{
|
|
|
|
|
int error, table_type;
|
|
|
|
|
bool error_given;
|
|
|
|
|
File file;
|
|
|
|
|
uchar head[288], *disk_buff;
|
|
|
|
|
char path[FN_REFLEN];
|
2004-11-08 00:13:54 +01:00
|
|
|
MEM_ROOT **root_ptr, *old_root;
|
2005-11-23 21:45:02 +01:00
|
|
|
DBUG_ENTER("open_table_def");
|
2006-08-02 17:57:06 +02:00
|
|
|
DBUG_PRINT("enter", ("table: '%s'.'%s' path: '%s'", share->db.str,
|
|
|
|
|
share->table_name.str, share->normalized_path.str));
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
error= 1;
|
2005-11-23 21:45:02 +01:00
|
|
|
error_given= 0;
|
2005-01-06 12:00:13 +01:00
|
|
|
disk_buff= NULL;
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
strxmov(path, share->normalized_path.str, reg_ext, NullS);
|
|
|
|
|
if ((file= my_open(path, O_RDONLY | O_SHARE, MYF(0))) < 0)
|
2006-01-24 14:33:39 +01:00
|
|
|
{
|
2007-06-14 13:28:33 +02:00
|
|
|
/*
|
|
|
|
|
We don't try to open 5.0 unencoded name, if
|
|
|
|
|
- non-encoded name contains '@' signs,
|
|
|
|
|
because '@' can be misinterpreted.
|
|
|
|
|
It is not clear if '@' is escape character in 5.1,
|
|
|
|
|
or a normal character in 5.0.
|
|
|
|
|
|
|
|
|
|
- non-encoded db or table name contain "#mysql50#" prefix.
|
|
|
|
|
This kind of tables must have been opened only by the
|
|
|
|
|
my_open() above.
|
|
|
|
|
*/
|
|
|
|
|
if (strchr(share->table_name.str, '@') ||
|
|
|
|
|
!strncmp(share->db.str, MYSQL50_TABLE_NAME_PREFIX,
|
|
|
|
|
MYSQL50_TABLE_NAME_PREFIX_LENGTH) ||
|
|
|
|
|
!strncmp(share->table_name.str, MYSQL50_TABLE_NAME_PREFIX,
|
|
|
|
|
MYSQL50_TABLE_NAME_PREFIX_LENGTH))
|
2006-03-07 10:05:24 +01:00
|
|
|
goto err_not_open;
|
|
|
|
|
|
2007-06-14 13:28:33 +02:00
|
|
|
/* Try unencoded 5.0 name */
|
2006-01-24 14:33:39 +01:00
|
|
|
uint length;
|
|
|
|
|
strxnmov(path, sizeof(path)-1,
|
|
|
|
|
mysql_data_home, "/", share->db.str, "/",
|
|
|
|
|
share->table_name.str, reg_ext, NullS);
|
|
|
|
|
length= unpack_filename(path, path) - reg_ext_length;
|
|
|
|
|
/*
|
|
|
|
|
The following is a safety test and should never fail
|
|
|
|
|
as the old file name should never be longer than the new one.
|
|
|
|
|
*/
|
|
|
|
|
DBUG_ASSERT(length <= share->normalized_path.length);
|
|
|
|
|
/*
|
|
|
|
|
If the old and the new names have the same length,
|
|
|
|
|
then table name does not have tricky characters,
|
|
|
|
|
so no need to check the old file name.
|
|
|
|
|
*/
|
|
|
|
|
if (length == share->normalized_path.length ||
|
|
|
|
|
((file= my_open(path, O_RDONLY | O_SHARE, MYF(0))) < 0))
|
|
|
|
|
goto err_not_open;
|
|
|
|
|
|
|
|
|
|
/* Unencoded 5.0 table name found */
|
|
|
|
|
path[length]= '\0'; // Remove .frm extension
|
|
|
|
|
strmov(share->normalized_path.str, path);
|
|
|
|
|
share->normalized_path.length= length;
|
|
|
|
|
}
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
error= 4;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (my_read(file, head, 64, MYF(MY_NABP)))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err;
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
if (head[0] == (uchar) 254 && head[1] == 1)
|
2004-07-16 00:15:55 +02:00
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
if (head[2] == FRM_VER || head[2] == FRM_VER+1 ||
|
|
|
|
|
(head[2] >= FRM_VER+3 && head[2] <= FRM_VER+4))
|
2007-08-03 00:14:05 +02:00
|
|
|
{
|
|
|
|
|
/* Open view only */
|
|
|
|
|
if (db_flags & OPEN_VIEW_ONLY)
|
|
|
|
|
{
|
|
|
|
|
error_given= 1;
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
table_type= 1;
|
2007-08-03 00:14:05 +02:00
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
error= 6; // Unkown .frm version
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-11-23 21:58:53 +01:00
|
|
|
else if (memcmp(head, STRING_WITH_LEN("TYPE=")) == 0)
|
2005-11-23 21:45:02 +01:00
|
|
|
{
|
|
|
|
|
error= 5;
|
|
|
|
|
if (memcmp(head+5,"VIEW",4) == 0)
|
|
|
|
|
{
|
|
|
|
|
share->is_view= 1;
|
|
|
|
|
if (db_flags & OPEN_VIEW)
|
|
|
|
|
error= 0;
|
|
|
|
|
}
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
else
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err;
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
/* No handling of text based files yet */
|
|
|
|
|
if (table_type == 1)
|
|
|
|
|
{
|
|
|
|
|
root_ptr= my_pthread_getspecific_ptr(MEM_ROOT**, THR_MALLOC);
|
|
|
|
|
old_root= *root_ptr;
|
|
|
|
|
*root_ptr= &share->mem_root;
|
|
|
|
|
error= open_binary_frm(thd, share, head, file);
|
|
|
|
|
*root_ptr= old_root;
|
|
|
|
|
error_given= 1;
|
2004-07-16 00:15:55 +02:00
|
|
|
}
|
|
|
|
|
|
WL#3984 (Revise locking of mysql.general_log and mysql.slow_log)
Bug#25422 (Hang with log tables)
Bug 17876 (Truncating mysql.slow_log in a SP after using cursor locks the
thread)
Bug 23044 (Warnings on flush of a log table)
Bug 29129 (Resetting general_log while the GLOBAL READ LOCK is set causes
a deadlock)
Prior to this fix, the server would hang when performing concurrent
ALTER TABLE or TRUNCATE TABLE statements against the LOG TABLES,
which are mysql.general_log and mysql.slow_log.
The root cause traces to the following code:
in sql_base.cc, open_table()
if (table->in_use != thd)
{
/* wait_for_condition will unlock LOCK_open for us */
wait_for_condition(thd, &LOCK_open, &COND_refresh);
}
The problem with this code is that the current implementation of the
LOGGER creates 'fake' THD objects, like
- Log_to_csv_event_handler::general_log_thd
- Log_to_csv_event_handler::slow_log_thd
which are not associated to a real thread running in the server,
so that waiting for these non-existing threads to release table locks
cause the dead lock.
In general, the design of Log_to_csv_event_handler does not fit into the
general architecture of the server, so that the concept of general_log_thd
and slow_log_thd has to be abandoned:
- this implementation does not work with table locking
- it will not work with commands like SHOW PROCESSLIST
- having the log tables always opened does not integrate well with DDL
operations / FLUSH TABLES / SET GLOBAL READ_ONLY
With this patch, the fundamental design of the LOGGER has been changed to:
- always open and close a log table when writing a log
- remove totally the usage of fake THD objects
- clarify how locking of log tables is implemented in general.
See WL#3984 for details related to the new locking design.
Additional changes (misc bugs exposed and fixed):
1)
mysqldump which would ignore some tables in dump_all_tables_in_db(),
but forget to ignore the same in dump_all_views_in_db().
2)
mysqldump would also issue an empty "LOCK TABLE" command when all the tables
to lock are to be ignored (numrows == 0), instead of not issuing the query.
3)
Internal errors handlers could intercept errors but not warnings
(see sql_error.cc).
4)
Implementing a nested call to open tables, for the performance schema tables,
exposed an existing bug in remove_table_from_cache(), which would perform:
in_use->some_tables_deleted=1;
against another thread, without any consideration about thread locking.
This call inside remove_table_from_cache() was not required anyway,
since calling mysql_lock_abort() takes care of aborting -- cleanly -- threads
that might hold a lock on a table.
This line (in_use->some_tables_deleted=1) has been removed.
2007-07-27 08:31:06 +02:00
|
|
|
share->table_category= get_table_category(& share->db, & share->table_name);
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
if (!error)
|
|
|
|
|
thd->status_var.opened_shares++;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
err:
|
|
|
|
|
my_close(file, MYF(MY_WME));
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
err_not_open:
|
|
|
|
|
if (error && !error_given)
|
2005-05-07 22:57:22 +02:00
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
share->error= error;
|
|
|
|
|
open_table_error(share, error, (share->open_errno= my_errno), 0);
|
2005-05-07 22:57:22 +02:00
|
|
|
}
|
2006-02-23 13:34:03 +01:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
DBUG_RETURN(error);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Read data from a binary .frm file from MySQL 3.23 - 5.0 into TABLE_SHARE
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
|
|
|
|
|
File file)
|
|
|
|
|
{
|
|
|
|
|
int error, errarg= 0;
|
|
|
|
|
uint new_frm_ver, field_pack_length, new_field_pack_flag;
|
|
|
|
|
uint interval_count, interval_parts, read_length, int_length;
|
|
|
|
|
uint db_create_options, keys, key_parts, n_length;
|
|
|
|
|
uint key_info_length, com_length, null_bit_pos;
|
|
|
|
|
uint extra_rec_buf_length;
|
|
|
|
|
uint i,j;
|
|
|
|
|
bool use_hash;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
char *keynames, *names, *comment_pos;
|
|
|
|
|
uchar *record;
|
2005-11-23 21:45:02 +01:00
|
|
|
uchar *disk_buff, *strpos, *null_flags, *null_pos;
|
|
|
|
|
ulong pos, record_offset, *rec_per_key, rec_buff_length;
|
|
|
|
|
handler *handler_file= 0;
|
|
|
|
|
KEY *keyinfo;
|
|
|
|
|
KEY_PART_INFO *key_part;
|
|
|
|
|
SQL_CRYPT *crypted=0;
|
|
|
|
|
Field **field_ptr, *reg_field;
|
|
|
|
|
const char **interval_array;
|
2005-12-21 19:18:40 +01:00
|
|
|
enum legacy_db_type legacy_db_type;
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
my_bitmap_map *bitmaps;
|
2005-11-23 21:45:02 +01:00
|
|
|
DBUG_ENTER("open_binary_frm");
|
|
|
|
|
|
|
|
|
|
new_field_pack_flag= head[27];
|
2002-06-02 20:22:20 +02:00
|
|
|
new_frm_ver= (head[2] - FRM_VER);
|
2003-02-07 14:47:24 +01:00
|
|
|
field_pack_length= new_frm_ver < 2 ? 11 : 17;
|
2005-11-23 21:45:02 +01:00
|
|
|
disk_buff= 0;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
error= 3;
|
2000-07-31 21:29:14 +02:00
|
|
|
if (!(pos=get_form_pos(file,head,(TYPELIB*) 0)))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err; /* purecov: inspected */
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
share->frm_version= head[2];
|
2005-03-22 14:48:06 +01:00
|
|
|
/*
|
|
|
|
|
Check if .frm file created by MySQL 5.0. In this case we want to
|
|
|
|
|
display CHAR fields as CHAR and not as VARCHAR.
|
|
|
|
|
We do it this way as we want to keep the old frm version to enable
|
|
|
|
|
MySQL 4.1 to read these files.
|
|
|
|
|
*/
|
|
|
|
|
if (share->frm_version == FRM_VER_TRUE_VARCHAR -1 && head[33] == 5)
|
|
|
|
|
share->frm_version= FRM_VER_TRUE_VARCHAR;
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
#ifdef WITH_PARTITION_STORAGE_ENGINE
|
2006-08-16 17:07:12 +02:00
|
|
|
if (*(head+61) &&
|
|
|
|
|
!(share->default_part_db_type=
|
|
|
|
|
ha_checktype(thd, (enum legacy_db_type) (uint) *(head+61), 1, 0)))
|
|
|
|
|
goto err;
|
2006-01-17 08:40:00 +01:00
|
|
|
DBUG_PRINT("info", ("default_part_db_type = %u", head[61]));
|
2005-11-23 21:45:02 +01:00
|
|
|
#endif
|
2005-12-21 19:18:40 +01:00
|
|
|
legacy_db_type= (enum legacy_db_type) (uint) *(head+3);
|
2007-03-23 18:14:46 +01:00
|
|
|
DBUG_ASSERT(share->db_plugin == NULL);
|
|
|
|
|
/*
|
|
|
|
|
if the storage engine is dynamic, no point in resolving it by its
|
|
|
|
|
dynamically allocated legacy_db_type. We will resolve it later by name.
|
|
|
|
|
*/
|
|
|
|
|
if (legacy_db_type > DB_TYPE_UNKNOWN &&
|
|
|
|
|
legacy_db_type < DB_TYPE_FIRST_DYNAMIC)
|
|
|
|
|
share->db_plugin= ha_lock_engine(NULL,
|
|
|
|
|
ha_checktype(thd, legacy_db_type, 0, 0));
|
2005-11-23 21:45:02 +01:00
|
|
|
share->db_create_options= db_create_options= uint2korr(head+30);
|
2005-01-06 12:00:13 +01:00
|
|
|
share->db_options_in_use= share->db_create_options;
|
2005-05-25 17:33:36 +02:00
|
|
|
share->mysql_version= uint4korr(head+51);
|
2005-11-23 21:45:02 +01:00
|
|
|
share->null_field_first= 0;
|
2000-07-31 21:29:14 +02:00
|
|
|
if (!head[32]) // New frm file in 3.23
|
|
|
|
|
{
|
2005-01-06 12:00:13 +01:00
|
|
|
share->avg_row_length= uint4korr(head+34);
|
2007-10-11 17:07:40 +02:00
|
|
|
share->transactional= (ha_choice) (head[39] & 3);
|
|
|
|
|
share->page_checksum= (ha_choice) ((head[39] >> 2) & 3);
|
2007-08-13 15:11:25 +02:00
|
|
|
share->row_type= (row_type) head[40];
|
2005-01-06 12:00:13 +01:00
|
|
|
share->table_charset= get_charset((uint) head[38],MYF(0));
|
2005-11-23 21:45:02 +01:00
|
|
|
share->null_field_first= 1;
|
2005-01-06 12:00:13 +01:00
|
|
|
}
|
|
|
|
|
if (!share->table_charset)
|
|
|
|
|
{
|
|
|
|
|
/* unknown charset in head[38] or pre-3.23 frm */
|
2005-01-17 21:22:23 +01:00
|
|
|
if (use_mb(default_charset_info))
|
|
|
|
|
{
|
|
|
|
|
/* Warn that we may be changing the size of character columns */
|
|
|
|
|
sql_print_warning("'%s' had no or invalid character set, "
|
|
|
|
|
"and default character set is multi-byte, "
|
|
|
|
|
"so character column sizes may have changed",
|
2006-11-01 18:41:09 +01:00
|
|
|
share->path.str);
|
2005-01-17 21:22:23 +01:00
|
|
|
}
|
2005-01-06 12:00:13 +01:00
|
|
|
share->table_charset= default_charset_info;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2005-01-06 12:00:13 +01:00
|
|
|
share->db_record_offset= 1;
|
2000-07-31 21:29:14 +02:00
|
|
|
if (db_create_options & HA_OPTION_LONG_BLOB_PTR)
|
2005-01-06 12:00:13 +01:00
|
|
|
share->blob_ptr_size= portable_sizeof_char_ptr;
|
2004-10-07 00:45:06 +02:00
|
|
|
/* Set temporarily a good value for db_low_byte_first */
|
2005-12-21 19:18:40 +01:00
|
|
|
share->db_low_byte_first= test(legacy_db_type != DB_TYPE_ISAM);
|
2000-07-31 21:29:14 +02:00
|
|
|
error=4;
|
2005-01-06 12:00:13 +01:00
|
|
|
share->max_rows= uint4korr(head+18);
|
|
|
|
|
share->min_rows= uint4korr(head+22);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
/* Read keyinformation */
|
2002-04-12 20:35:46 +02:00
|
|
|
key_info_length= (uint) uint2korr(head+28);
|
2000-07-31 21:29:14 +02:00
|
|
|
VOID(my_seek(file,(ulong) uint2korr(head+6),MY_SEEK_SET,MYF(0)));
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (read_string(file,(uchar**) &disk_buff,key_info_length))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err; /* purecov: inspected */
|
2003-10-30 19:17:57 +01:00
|
|
|
if (disk_buff[0] & 0x80)
|
2003-10-21 00:13:17 +02:00
|
|
|
{
|
2005-01-06 12:00:13 +01:00
|
|
|
share->keys= keys= (disk_buff[1] << 7) | (disk_buff[0] & 0x7f);
|
|
|
|
|
share->key_parts= key_parts= uint2korr(disk_buff+2);
|
2003-10-21 00:13:17 +02:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2005-01-06 12:00:13 +01:00
|
|
|
share->keys= keys= disk_buff[0];
|
|
|
|
|
share->key_parts= key_parts= disk_buff[1];
|
2003-10-21 00:13:17 +02:00
|
|
|
}
|
2005-01-06 12:00:13 +01:00
|
|
|
share->keys_for_keyread.init(0);
|
|
|
|
|
share->keys_in_use.init(keys);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
n_length=keys*sizeof(KEY)+key_parts*sizeof(KEY_PART_INFO);
|
2005-11-23 21:45:02 +01:00
|
|
|
if (!(keyinfo = (KEY*) alloc_root(&share->mem_root,
|
|
|
|
|
n_length + uint2korr(disk_buff+4))))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err; /* purecov: inspected */
|
2000-07-31 21:29:14 +02:00
|
|
|
bzero((char*) keyinfo,n_length);
|
2005-11-23 21:45:02 +01:00
|
|
|
share->key_info= keyinfo;
|
2003-01-05 19:18:49 +01:00
|
|
|
key_part= my_reinterpret_cast(KEY_PART_INFO*) (keyinfo+keys);
|
2000-07-31 21:29:14 +02:00
|
|
|
strpos=disk_buff+6;
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
if (!(rec_per_key= (ulong*) alloc_root(&share->mem_root,
|
2000-07-31 21:29:14 +02:00
|
|
|
sizeof(ulong*)*key_parts)))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
for (i=0 ; i < keys ; i++, keyinfo++)
|
|
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
keyinfo->table= 0; // Updated in open_frm
|
2004-12-06 01:00:37 +01:00
|
|
|
if (new_frm_ver >= 3)
|
2002-06-02 20:22:20 +02:00
|
|
|
{
|
|
|
|
|
keyinfo->flags= (uint) uint2korr(strpos) ^ HA_NOSAME;
|
|
|
|
|
keyinfo->key_length= (uint) uint2korr(strpos+2);
|
|
|
|
|
keyinfo->key_parts= (uint) strpos[4];
|
|
|
|
|
keyinfo->algorithm= (enum ha_key_alg) strpos[5];
|
2006-05-03 14:59:17 +02:00
|
|
|
keyinfo->block_size= uint2korr(strpos+6);
|
2002-06-02 20:22:20 +02:00
|
|
|
strpos+=8;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
keyinfo->flags= ((uint) strpos[0]) ^ HA_NOSAME;
|
|
|
|
|
keyinfo->key_length= (uint) uint2korr(strpos+1);
|
|
|
|
|
keyinfo->key_parts= (uint) strpos[3];
|
|
|
|
|
keyinfo->algorithm= HA_KEY_ALG_UNDEF;
|
|
|
|
|
strpos+=4;
|
|
|
|
|
}
|
2002-02-22 12:24:42 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
keyinfo->key_part= key_part;
|
|
|
|
|
keyinfo->rec_per_key= rec_per_key;
|
|
|
|
|
for (j=keyinfo->key_parts ; j-- ; key_part++)
|
|
|
|
|
{
|
|
|
|
|
*rec_per_key++=0;
|
|
|
|
|
key_part->fieldnr= (uint16) (uint2korr(strpos) & FIELD_NR_MASK);
|
|
|
|
|
key_part->offset= (uint) uint2korr(strpos+2)-1;
|
|
|
|
|
key_part->key_type= (uint) uint2korr(strpos+5);
|
|
|
|
|
// key_part->field= (Field*) 0; // Will be fixed later
|
2002-06-02 20:22:20 +02:00
|
|
|
if (new_frm_ver >= 1)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
key_part->key_part_flag= *(strpos+4);
|
|
|
|
|
key_part->length= (uint) uint2korr(strpos+7);
|
|
|
|
|
strpos+=9;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
key_part->length= *(strpos+4);
|
|
|
|
|
key_part->key_part_flag=0;
|
|
|
|
|
if (key_part->length > 128)
|
|
|
|
|
{
|
|
|
|
|
key_part->length&=127; /* purecov: inspected */
|
|
|
|
|
key_part->key_part_flag=HA_REVERSE_SORT; /* purecov: inspected */
|
|
|
|
|
}
|
|
|
|
|
strpos+=7;
|
|
|
|
|
}
|
|
|
|
|
key_part->store_length=key_part->length;
|
|
|
|
|
}
|
|
|
|
|
}
|
2002-04-12 20:35:46 +02:00
|
|
|
keynames=(char*) key_part;
|
|
|
|
|
strpos+= (strmov(keynames, (char *) strpos) - keynames)+1;
|
2002-06-18 23:22:30 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
share->reclength = uint2korr((head+16));
|
2000-07-31 21:29:14 +02:00
|
|
|
if (*(head+26) == 1)
|
2005-01-06 12:00:13 +01:00
|
|
|
share->system= 1; /* one-record-database */
|
2000-07-31 21:29:14 +02:00
|
|
|
#ifdef HAVE_CRYPTED_FRM
|
|
|
|
|
else if (*(head+26) == 2)
|
|
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
crypted= get_crypt_for_frm();
|
|
|
|
|
share->crypted= 1;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-10-10 20:01:45 +02:00
|
|
|
record_offset= (ulong) (uint2korr(head+6)+
|
|
|
|
|
((uint2korr(head+14) == 0xffff ?
|
|
|
|
|
uint4korr(head+47) : uint2korr(head+14))));
|
|
|
|
|
|
2006-01-17 08:40:00 +01:00
|
|
|
if ((n_length= uint4korr(head+55)))
|
2005-10-10 20:01:45 +02:00
|
|
|
{
|
|
|
|
|
/* Read extra data segment */
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
uchar *buff, *next_chunk, *buff_end;
|
2005-11-05 12:20:35 +01:00
|
|
|
DBUG_PRINT("info", ("extra segment size is %u bytes", n_length));
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (!(next_chunk= buff= (uchar*) my_malloc(n_length, MYF(MY_WME))))
|
2005-10-10 20:01:45 +02:00
|
|
|
goto err;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (my_pread(file, buff, n_length, record_offset + share->reclength,
|
2005-10-10 20:01:45 +02:00
|
|
|
MYF(MY_NABP)))
|
|
|
|
|
{
|
|
|
|
|
my_free(buff, MYF(0));
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
2005-10-10 20:53:53 +02:00
|
|
|
share->connect_string.length= uint2korr(buff);
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (!(share->connect_string.str= strmake_root(&share->mem_root,
|
|
|
|
|
(char*) next_chunk + 2,
|
|
|
|
|
share->connect_string.
|
|
|
|
|
length)))
|
2005-10-10 20:01:45 +02:00
|
|
|
{
|
2005-10-10 20:53:53 +02:00
|
|
|
my_free(buff, MYF(0));
|
|
|
|
|
goto err;
|
2005-10-10 20:01:45 +02:00
|
|
|
}
|
2005-10-10 20:53:53 +02:00
|
|
|
next_chunk+= share->connect_string.length + 2;
|
2005-11-05 12:20:35 +01:00
|
|
|
buff_end= buff + n_length;
|
2005-10-10 20:01:45 +02:00
|
|
|
if (next_chunk + 2 < buff_end)
|
|
|
|
|
{
|
|
|
|
|
uint str_db_type_length= uint2korr(next_chunk);
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
LEX_STRING name;
|
|
|
|
|
name.str= (char*) next_chunk + 2;
|
|
|
|
|
name.length= str_db_type_length;
|
|
|
|
|
|
2007-03-02 17:43:45 +01:00
|
|
|
plugin_ref tmp_plugin= ha_resolve_by_name(thd, &name);
|
2007-03-23 18:14:46 +01:00
|
|
|
if (tmp_plugin != NULL && !plugin_equals(tmp_plugin, share->db_plugin))
|
2005-11-05 12:20:35 +01:00
|
|
|
{
|
2007-03-23 18:14:46 +01:00
|
|
|
if (legacy_db_type > DB_TYPE_UNKNOWN &&
|
|
|
|
|
legacy_db_type < DB_TYPE_FIRST_DYNAMIC &&
|
|
|
|
|
legacy_db_type != ha_legacy_type(
|
|
|
|
|
plugin_data(tmp_plugin, handlerton *)))
|
|
|
|
|
{
|
|
|
|
|
/* bad file, legacy_db_type did not match the name */
|
|
|
|
|
my_free(buff, MYF(0));
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
2007-03-02 17:43:45 +01:00
|
|
|
/*
|
|
|
|
|
tmp_plugin is locked with a local lock.
|
|
|
|
|
we unlock the old value of share->db_plugin before
|
|
|
|
|
replacing it with a globally locked version of tmp_plugin
|
|
|
|
|
*/
|
|
|
|
|
plugin_unlock(NULL, share->db_plugin);
|
|
|
|
|
share->db_plugin= my_plugin_lock(NULL, &tmp_plugin);
|
2005-11-05 12:20:35 +01:00
|
|
|
DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
|
|
|
|
|
str_db_type_length, next_chunk + 2,
|
2007-03-02 17:43:45 +01:00
|
|
|
ha_legacy_type(share->db_type())));
|
2005-11-05 12:20:35 +01:00
|
|
|
}
|
2005-11-07 16:25:06 +01:00
|
|
|
#ifdef WITH_PARTITION_STORAGE_ENGINE
|
2007-12-14 14:05:27 +01:00
|
|
|
else if (str_db_type_length == 9 &&
|
|
|
|
|
!strncmp((char *) next_chunk + 2, "partition", 9))
|
2005-11-05 12:20:35 +01:00
|
|
|
{
|
2007-12-14 14:05:27 +01:00
|
|
|
/*
|
|
|
|
|
Use partition handler
|
|
|
|
|
tmp_plugin is locked with a local lock.
|
|
|
|
|
we unlock the old value of share->db_plugin before
|
|
|
|
|
replacing it with a globally locked version of tmp_plugin
|
|
|
|
|
*/
|
|
|
|
|
plugin_unlock(NULL, share->db_plugin);
|
|
|
|
|
share->db_plugin= ha_lock_engine(NULL, partition_hton);
|
|
|
|
|
DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
|
|
|
|
|
str_db_type_length, next_chunk + 2,
|
|
|
|
|
ha_legacy_type(share->db_type())));
|
2005-11-05 12:20:35 +01:00
|
|
|
}
|
|
|
|
|
#endif
|
2007-12-14 14:05:27 +01:00
|
|
|
else if (!tmp_plugin)
|
|
|
|
|
{
|
|
|
|
|
/* purecov: begin inspected */
|
|
|
|
|
error= 8;
|
|
|
|
|
my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), name.str);
|
|
|
|
|
my_free(buff, MYF(0));
|
|
|
|
|
goto err;
|
|
|
|
|
/* purecov: end */
|
|
|
|
|
}
|
2005-10-10 20:01:45 +02:00
|
|
|
next_chunk+= str_db_type_length + 2;
|
|
|
|
|
}
|
2005-12-29 14:28:59 +01:00
|
|
|
if (next_chunk + 5 < buff_end)
|
2005-11-05 12:20:35 +01:00
|
|
|
{
|
2005-11-25 10:33:38 +01:00
|
|
|
uint32 partition_info_len = uint4korr(next_chunk);
|
|
|
|
|
#ifdef WITH_PARTITION_STORAGE_ENGINE
|
2007-06-01 16:44:09 +02:00
|
|
|
if ((share->partition_info_buffer_size=
|
|
|
|
|
share->partition_info_len= partition_info_len))
|
2005-11-05 12:20:35 +01:00
|
|
|
{
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (!(share->partition_info= (char*)
|
2007-03-27 19:09:56 +02:00
|
|
|
memdup_root(&share->mem_root, next_chunk + 4,
|
|
|
|
|
partition_info_len + 1)))
|
2005-11-05 12:20:35 +01:00
|
|
|
{
|
|
|
|
|
my_free(buff, MYF(0));
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
2005-11-25 10:33:38 +01:00
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
if (partition_info_len)
|
|
|
|
|
{
|
|
|
|
|
DBUG_PRINT("info", ("WITH_PARTITION_STORAGE_ENGINE is not defined"));
|
|
|
|
|
my_free(buff, MYF(0));
|
|
|
|
|
goto err;
|
2005-11-05 12:20:35 +01:00
|
|
|
}
|
2005-11-25 10:33:38 +01:00
|
|
|
#endif
|
2005-12-29 14:28:59 +01:00
|
|
|
next_chunk+= 5 + partition_info_len;
|
2005-11-05 12:20:35 +01:00
|
|
|
}
|
2006-04-16 03:49:13 +02:00
|
|
|
#if MYSQL_VERSION_ID < 50200
|
|
|
|
|
if (share->mysql_version >= 50106 && share->mysql_version <= 50109)
|
2006-01-17 08:40:00 +01:00
|
|
|
{
|
|
|
|
|
/*
|
2006-04-16 03:49:13 +02:00
|
|
|
Partition state array was here in version 5.1.6 to 5.1.9, this code
|
|
|
|
|
makes it possible to load a 5.1.6 table in later versions. Can most
|
|
|
|
|
likely be removed at some point in time. Will only be used for
|
|
|
|
|
upgrades within 5.1 series of versions. Upgrade to 5.2 can only be
|
|
|
|
|
done from newer 5.1 versions.
|
2006-01-17 08:40:00 +01:00
|
|
|
*/
|
2006-02-01 17:05:22 +01:00
|
|
|
next_chunk+= 4;
|
2006-01-17 08:40:00 +01:00
|
|
|
}
|
2006-05-10 18:53:40 +02:00
|
|
|
else if (share->mysql_version >= 50110)
|
2006-01-17 08:40:00 +01:00
|
|
|
#endif
|
2006-05-10 18:53:40 +02:00
|
|
|
{
|
|
|
|
|
/* New auto_partitioned indicator introduced in 5.1.11 */
|
|
|
|
|
#ifdef WITH_PARTITION_STORAGE_ENGINE
|
|
|
|
|
share->auto_partitioned= *next_chunk;
|
|
|
|
|
#endif
|
|
|
|
|
next_chunk++;
|
|
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
keyinfo= share->key_info;
|
2005-11-05 12:20:35 +01:00
|
|
|
for (i= 0; i < keys; i++, keyinfo++)
|
|
|
|
|
{
|
|
|
|
|
if (keyinfo->flags & HA_USES_PARSER)
|
|
|
|
|
{
|
|
|
|
|
LEX_STRING parser_name;
|
|
|
|
|
if (next_chunk >= buff_end)
|
|
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
DBUG_PRINT("error",
|
|
|
|
|
("fulltext key uses parser that is not defined in .frm"));
|
2005-11-05 12:20:35 +01:00
|
|
|
my_free(buff, MYF(0));
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
parser_name.str= (char*) next_chunk;
|
|
|
|
|
parser_name.length= strlen((char*) next_chunk);
|
2007-08-03 00:50:19 +02:00
|
|
|
next_chunk+= parser_name.length + 1;
|
2007-03-02 17:43:45 +01:00
|
|
|
keyinfo->parser= my_plugin_lock_by_name(NULL, &parser_name,
|
|
|
|
|
MYSQL_FTPARSER_PLUGIN);
|
2005-11-05 12:20:35 +01:00
|
|
|
if (! keyinfo->parser)
|
|
|
|
|
{
|
|
|
|
|
my_error(ER_PLUGIN_IS_NOT_LOADED, MYF(0), parser_name.str);
|
2006-04-06 15:49:00 +02:00
|
|
|
my_free(buff, MYF(0));
|
2005-11-05 12:20:35 +01:00
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-10-10 20:01:45 +02:00
|
|
|
my_free(buff, MYF(0));
|
|
|
|
|
}
|
2006-05-03 14:59:17 +02:00
|
|
|
share->key_block_size= uint2korr(head+62);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
error=4;
|
2005-07-18 13:31:02 +02:00
|
|
|
extra_rec_buf_length= uint2korr(head+59);
|
2005-11-23 21:45:02 +01:00
|
|
|
rec_buff_length= ALIGN_SIZE(share->reclength + 1 + extra_rec_buf_length);
|
2005-01-06 12:00:13 +01:00
|
|
|
share->rec_buff_length= rec_buff_length;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (!(record= (uchar *) alloc_root(&share->mem_root,
|
|
|
|
|
rec_buff_length)))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err; /* purecov: inspected */
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
share->default_values= record;
|
|
|
|
|
if (my_pread(file, record, (size_t) share->reclength,
|
2005-09-13 03:02:17 +02:00
|
|
|
record_offset, MYF(MY_NABP)))
|
2005-11-23 21:45:02 +01:00
|
|
|
goto err; /* purecov: inspected */
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
VOID(my_seek(file,pos,MY_SEEK_SET,MYF(0)));
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (my_read(file, head,288,MYF(MY_NABP)))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err;
|
2005-01-24 15:48:25 +01:00
|
|
|
#ifdef HAVE_CRYPTED_FRM
|
2000-07-31 21:29:14 +02:00
|
|
|
if (crypted)
|
|
|
|
|
{
|
|
|
|
|
crypted->decode((char*) head+256,288-256);
|
|
|
|
|
if (sint2korr(head+284) != 0) // Should be 0
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err; // Wrong password
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2005-01-24 15:48:25 +01:00
|
|
|
#endif
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
share->fields= uint2korr(head+258);
|
|
|
|
|
pos= uint2korr(head+260); /* Length of all screens */
|
|
|
|
|
n_length= uint2korr(head+268);
|
|
|
|
|
interval_count= uint2korr(head+270);
|
|
|
|
|
interval_parts= uint2korr(head+272);
|
|
|
|
|
int_length= uint2korr(head+274);
|
|
|
|
|
share->null_fields= uint2korr(head+282);
|
|
|
|
|
com_length= uint2korr(head+284);
|
2006-06-29 15:39:34 +02:00
|
|
|
share->comment.length= (int) (head[46]);
|
2006-07-18 15:43:55 +02:00
|
|
|
share->comment.str= strmake_root(&share->mem_root, (char*) head+47,
|
2006-06-29 15:39:34 +02:00
|
|
|
share->comment.length);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
DBUG_PRINT("info",("i_count: %d i_parts: %d index: %d n_length: %d int_length: %d com_length: %d", interval_count,interval_parts, share->keys,n_length,int_length, com_length));
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
if (!(field_ptr = (Field **)
|
2005-11-23 21:45:02 +01:00
|
|
|
alloc_root(&share->mem_root,
|
2005-01-06 12:00:13 +01:00
|
|
|
(uint) ((share->fields+1)*sizeof(Field*)+
|
2000-07-31 21:29:14 +02:00
|
|
|
interval_count*sizeof(TYPELIB)+
|
2005-01-06 12:00:13 +01:00
|
|
|
(share->fields+interval_parts+
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
keys+3)*sizeof(char *)+
|
2002-06-02 20:22:20 +02:00
|
|
|
(n_length+int_length+com_length)))))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err; /* purecov: inspected */
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
share->field= field_ptr;
|
2005-01-06 12:00:13 +01:00
|
|
|
read_length=(uint) (share->fields * field_pack_length +
|
2002-06-04 07:23:57 +02:00
|
|
|
pos+ (uint) (n_length+int_length+com_length));
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (read_string(file,(uchar**) &disk_buff,read_length))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err; /* purecov: inspected */
|
2005-01-24 15:48:25 +01:00
|
|
|
#ifdef HAVE_CRYPTED_FRM
|
2000-07-31 21:29:14 +02:00
|
|
|
if (crypted)
|
|
|
|
|
{
|
|
|
|
|
crypted->decode((char*) disk_buff,read_length);
|
|
|
|
|
delete crypted;
|
|
|
|
|
crypted=0;
|
|
|
|
|
}
|
2005-01-24 15:48:25 +01:00
|
|
|
#endif
|
2000-07-31 21:29:14 +02:00
|
|
|
strpos= disk_buff+pos;
|
|
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
share->intervals= (TYPELIB*) (field_ptr+share->fields+1);
|
2005-11-23 21:45:02 +01:00
|
|
|
interval_array= (const char **) (share->intervals+interval_count);
|
|
|
|
|
names= (char*) (interval_array+share->fields+interval_parts+keys+3);
|
2000-07-31 21:29:14 +02:00
|
|
|
if (!interval_count)
|
2005-01-06 12:00:13 +01:00
|
|
|
share->intervals= 0; // For better debugging
|
|
|
|
|
memcpy((char*) names, strpos+(share->fields*field_pack_length),
|
2000-07-31 21:29:14 +02:00
|
|
|
(uint) (n_length+int_length));
|
2005-01-06 12:00:13 +01:00
|
|
|
comment_pos= names+(n_length+int_length);
|
2002-06-04 07:23:57 +02:00
|
|
|
memcpy(comment_pos, disk_buff+read_length-com_length, com_length);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
fix_type_pointers(&interval_array, &share->fieldnames, 1, &names);
|
2006-12-27 12:50:45 +01:00
|
|
|
if (share->fieldnames.count != share->fields)
|
|
|
|
|
goto err;
|
2005-11-23 21:45:02 +01:00
|
|
|
fix_type_pointers(&interval_array, share->intervals, interval_count,
|
2000-07-31 21:29:14 +02:00
|
|
|
&names);
|
2004-10-25 14:51:26 +02:00
|
|
|
|
|
|
|
|
{
|
|
|
|
|
/* Set ENUM and SET lengths */
|
|
|
|
|
TYPELIB *interval;
|
2005-01-06 12:00:13 +01:00
|
|
|
for (interval= share->intervals;
|
|
|
|
|
interval < share->intervals + interval_count;
|
2004-10-25 14:51:26 +02:00
|
|
|
interval++)
|
|
|
|
|
{
|
|
|
|
|
uint count= (uint) (interval->count + 1) * sizeof(uint);
|
2005-11-23 21:45:02 +01:00
|
|
|
if (!(interval->type_lengths= (uint *) alloc_root(&share->mem_root,
|
2004-10-25 14:51:26 +02:00
|
|
|
count)))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err;
|
2004-10-25 14:51:26 +02:00
|
|
|
for (count= 0; count < interval->count; count++)
|
2006-09-11 11:50:46 +02:00
|
|
|
{
|
|
|
|
|
char *val= (char*) interval->type_names[count];
|
|
|
|
|
interval->type_lengths[count]= strlen(val);
|
|
|
|
|
}
|
2004-10-25 14:51:26 +02:00
|
|
|
interval->type_lengths[count]= 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
if (keynames)
|
2005-11-23 21:45:02 +01:00
|
|
|
fix_type_pointers(&interval_array, &share->keynames, 1, &keynames);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
/* Allocate handler */
|
|
|
|
|
if (!(handler_file= get_new_handler(share, thd->mem_root,
|
2007-03-02 17:43:45 +01:00
|
|
|
share->db_type())))
|
2005-07-18 13:31:02 +02:00
|
|
|
goto err;
|
|
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
record= share->default_values-1; /* Fieldstart = 1 */
|
2005-11-23 21:45:02 +01:00
|
|
|
if (share->null_field_first)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
null_flags= null_pos= (uchar*) record+1;
|
2004-12-17 15:06:05 +01:00
|
|
|
null_bit_pos= (db_create_options & HA_OPTION_PACK_RECORD) ? 0 : 1;
|
2005-10-08 02:37:23 +02:00
|
|
|
/*
|
|
|
|
|
null_bytes below is only correct under the condition that
|
|
|
|
|
there are no bit fields. Correct values is set below after the
|
|
|
|
|
table struct is initialized
|
|
|
|
|
*/
|
2005-01-06 12:00:13 +01:00
|
|
|
share->null_bytes= (share->null_fields + null_bit_pos + 7) / 8;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
#ifndef WE_WANT_TO_SUPPORT_VERY_OLD_FRM_FILES
|
2000-07-31 21:29:14 +02:00
|
|
|
else
|
|
|
|
|
{
|
2005-01-06 12:00:13 +01:00
|
|
|
share->null_bytes= (share->null_fields+7)/8;
|
2005-11-23 21:45:02 +01:00
|
|
|
null_flags= null_pos= (uchar*) (record + 1 +share->reclength -
|
|
|
|
|
share->null_bytes);
|
2004-12-17 15:06:05 +01:00
|
|
|
null_bit_pos= 0;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
#endif
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH;
|
2000-07-31 21:29:14 +02:00
|
|
|
if (use_hash)
|
2005-01-06 12:00:13 +01:00
|
|
|
use_hash= !hash_init(&share->name_hash,
|
2002-03-14 18:44:42 +01:00
|
|
|
system_charset_info,
|
2005-01-06 12:00:13 +01:00
|
|
|
share->fields,0,0,
|
2003-04-01 09:45:16 +02:00
|
|
|
(hash_get_key) get_field_name,0,0);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
for (i=0 ; i < share->fields; i++, strpos+=field_pack_length, field_ptr++)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2003-02-07 14:47:24 +01:00
|
|
|
uint pack_flag, interval_nr, unireg_type, recpos, field_length;
|
2002-06-02 20:22:20 +02:00
|
|
|
enum_field_types field_type;
|
2002-10-25 10:58:32 +02:00
|
|
|
CHARSET_INFO *charset=NULL;
|
2003-03-27 10:09:09 +01:00
|
|
|
Field::geometry_type geom_type= Field::GEOM_GEOMETRY;
|
2002-06-02 20:22:20 +02:00
|
|
|
LEX_STRING comment;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2004-12-06 01:00:37 +01:00
|
|
|
if (new_frm_ver >= 3)
|
2002-06-02 20:22:20 +02:00
|
|
|
{
|
|
|
|
|
/* new frm file in 4.1 */
|
2003-02-07 14:47:24 +01:00
|
|
|
field_length= uint2korr(strpos+3);
|
|
|
|
|
recpos= uint3korr(strpos+5);
|
|
|
|
|
pack_flag= uint2korr(strpos+8);
|
|
|
|
|
unireg_type= (uint) strpos[10];
|
|
|
|
|
interval_nr= (uint) strpos[12];
|
|
|
|
|
uint comment_length=uint2korr(strpos+15);
|
|
|
|
|
field_type=(enum_field_types) (uint) strpos[13];
|
2003-03-27 10:09:09 +01:00
|
|
|
|
2004-12-06 01:00:37 +01:00
|
|
|
/* charset and geometry_type share the same byte in frm */
|
2006-12-02 02:26:52 +01:00
|
|
|
if (field_type == MYSQL_TYPE_GEOMETRY)
|
2003-03-27 10:09:09 +01:00
|
|
|
{
|
2004-01-15 18:06:22 +01:00
|
|
|
#ifdef HAVE_SPATIAL
|
2003-03-27 10:09:09 +01:00
|
|
|
geom_type= (Field::geometry_type) strpos[14];
|
|
|
|
|
charset= &my_charset_bin;
|
2004-01-15 18:06:22 +01:00
|
|
|
#else
|
|
|
|
|
error= 4; // unsupported field type
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err;
|
2004-01-15 18:06:22 +01:00
|
|
|
#endif
|
2003-03-27 10:09:09 +01:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2004-12-22 15:56:57 +01:00
|
|
|
if (!strpos[14])
|
|
|
|
|
charset= &my_charset_bin;
|
|
|
|
|
else if (!(charset=get_charset((uint) strpos[14], MYF(0))))
|
|
|
|
|
{
|
|
|
|
|
error= 5; // Unknown or unavailable charset
|
|
|
|
|
errarg= (int) strpos[14];
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err;
|
2004-12-22 15:56:57 +01:00
|
|
|
}
|
2003-03-27 10:09:09 +01:00
|
|
|
}
|
2002-06-02 20:22:20 +02:00
|
|
|
if (!comment_length)
|
|
|
|
|
{
|
|
|
|
|
comment.str= (char*) "";
|
|
|
|
|
comment.length=0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
comment.str= (char*) comment_pos;
|
|
|
|
|
comment.length= comment_length;
|
|
|
|
|
comment_pos+= comment_length;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2003-02-07 14:47:24 +01:00
|
|
|
field_length= (uint) strpos[3];
|
|
|
|
|
recpos= uint2korr(strpos+4),
|
|
|
|
|
pack_flag= uint2korr(strpos+6);
|
2004-10-02 21:20:08 +02:00
|
|
|
pack_flag&= ~FIELDFLAG_NO_DEFAULT; // Safety for old files
|
2003-02-07 14:47:24 +01:00
|
|
|
unireg_type= (uint) strpos[8];
|
|
|
|
|
interval_nr= (uint) strpos[10];
|
|
|
|
|
|
2002-06-02 20:22:20 +02:00
|
|
|
/* old frm file */
|
|
|
|
|
field_type= (enum_field_types) f_packtype(pack_flag);
|
2004-11-25 13:18:47 +01:00
|
|
|
if (f_is_binary(pack_flag))
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
Try to choose the best 4.1 type:
|
|
|
|
|
- for 4.0 "CHAR(N) BINARY" or "VARCHAR(N) BINARY"
|
|
|
|
|
try to find a binary collation for character set.
|
|
|
|
|
- for other types (e.g. BLOB) just use my_charset_bin.
|
|
|
|
|
*/
|
|
|
|
|
if (!f_is_blob(pack_flag))
|
|
|
|
|
{
|
|
|
|
|
// 3.23 or 4.0 string
|
2005-01-06 12:00:13 +01:00
|
|
|
if (!(charset= get_charset_by_csname(share->table_charset->csname,
|
2004-11-25 13:18:47 +01:00
|
|
|
MY_CS_BINSORT, MYF(0))))
|
|
|
|
|
charset= &my_charset_bin;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
charset= &my_charset_bin;
|
|
|
|
|
}
|
|
|
|
|
else
|
2005-01-06 12:00:13 +01:00
|
|
|
charset= share->table_charset;
|
2002-06-02 20:22:20 +02:00
|
|
|
bzero((char*) &comment, sizeof(comment));
|
|
|
|
|
}
|
2004-12-06 17:45:32 +01:00
|
|
|
|
|
|
|
|
if (interval_nr && charset->mbminlen > 1)
|
|
|
|
|
{
|
|
|
|
|
/* Unescape UCS2 intervals from HEX notation */
|
2005-01-06 12:00:13 +01:00
|
|
|
TYPELIB *interval= share->intervals + interval_nr - 1;
|
2004-12-21 14:12:27 +01:00
|
|
|
unhex_type2(interval);
|
2004-12-06 17:45:32 +01:00
|
|
|
}
|
|
|
|
|
|
2005-05-26 13:00:47 +02:00
|
|
|
#ifndef TO_BE_DELETED_ON_PRODUCTION
|
2006-12-02 02:26:52 +01:00
|
|
|
if (field_type == MYSQL_TYPE_NEWDECIMAL && !share->mysql_version)
|
2005-05-26 13:00:47 +02:00
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
Fix pack length of old decimal values from 5.0.3 -> 5.0.4
|
|
|
|
|
The difference is that in the old version we stored precision
|
|
|
|
|
in the .frm table while we now store the display_length
|
|
|
|
|
*/
|
|
|
|
|
uint decimals= f_decimals(pack_flag);
|
|
|
|
|
field_length= my_decimal_precision_to_length(field_length,
|
|
|
|
|
decimals,
|
|
|
|
|
f_is_dec(pack_flag) == 0);
|
2005-11-23 21:45:02 +01:00
|
|
|
sql_print_error("Found incompatible DECIMAL field '%s' in %s; "
|
|
|
|
|
"Please do \"ALTER TABLE '%s' FORCE\" to fix it!",
|
|
|
|
|
share->fieldnames.type_names[i], share->table_name.str,
|
|
|
|
|
share->table_name.str);
|
2005-05-26 13:00:47 +02:00
|
|
|
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
|
|
|
|
|
ER_CRASHED_ON_USAGE,
|
2005-11-23 21:45:02 +01:00
|
|
|
"Found incompatible DECIMAL field '%s' in %s; "
|
|
|
|
|
"Please do \"ALTER TABLE '%s' FORCE\" to fix it!",
|
|
|
|
|
share->fieldnames.type_names[i],
|
|
|
|
|
share->table_name.str,
|
|
|
|
|
share->table_name.str);
|
2005-05-26 13:00:47 +02:00
|
|
|
share->crashed= 1; // Marker for CHECK TABLE
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
*field_ptr= reg_field=
|
|
|
|
|
make_field(share, record+recpos,
|
2003-02-07 14:47:24 +01:00
|
|
|
(uint32) field_length,
|
2004-12-17 15:06:05 +01:00
|
|
|
null_pos, null_bit_pos,
|
2000-07-31 21:29:14 +02:00
|
|
|
pack_flag,
|
2002-06-02 20:22:20 +02:00
|
|
|
field_type,
|
2002-10-25 10:58:32 +02:00
|
|
|
charset,
|
2003-03-27 10:09:09 +01:00
|
|
|
geom_type,
|
2003-02-07 14:47:24 +01:00
|
|
|
(Field::utype) MTYP_TYPENR(unireg_type),
|
2000-07-31 21:29:14 +02:00
|
|
|
(interval_nr ?
|
2005-01-06 12:00:13 +01:00
|
|
|
share->intervals+interval_nr-1 :
|
2000-07-31 21:29:14 +02:00
|
|
|
(TYPELIB*) 0),
|
2005-11-23 21:45:02 +01:00
|
|
|
share->fieldnames.type_names[i]);
|
2002-11-21 14:56:48 +01:00
|
|
|
if (!reg_field) // Not supported field type
|
2002-11-07 03:02:37 +01:00
|
|
|
{
|
|
|
|
|
error= 4;
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err; /* purecov: inspected */
|
2002-11-07 03:02:37 +01:00
|
|
|
}
|
2005-05-25 17:33:36 +02:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
reg_field->field_index= i;
|
2002-06-02 20:22:20 +02:00
|
|
|
reg_field->comment=comment;
|
2006-12-02 02:26:52 +01:00
|
|
|
if (field_type == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag))
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2004-12-17 15:06:05 +01:00
|
|
|
if ((null_bit_pos+= field_length & 7) > 7)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2004-12-17 15:06:05 +01:00
|
|
|
null_pos++;
|
|
|
|
|
null_bit_pos-= 8;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
}
|
2004-12-17 15:06:05 +01:00
|
|
|
if (!(reg_field->flags & NOT_NULL_FLAG))
|
|
|
|
|
{
|
|
|
|
|
if (!(null_bit_pos= (null_bit_pos + 1) & 7))
|
|
|
|
|
null_pos++;
|
|
|
|
|
}
|
2004-10-02 21:20:08 +02:00
|
|
|
if (f_no_default(pack_flag))
|
|
|
|
|
reg_field->flags|= NO_DEFAULT_VALUE_FLAG;
|
2005-11-23 21:45:02 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
if (reg_field->unireg_check == Field::NEXT_NUMBER)
|
2005-11-23 21:45:02 +01:00
|
|
|
share->found_next_number_field= field_ptr;
|
|
|
|
|
if (share->timestamp_field == reg_field)
|
2005-01-06 12:00:13 +01:00
|
|
|
share->timestamp_field_offset= i;
|
2005-11-23 21:45:02 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
if (use_hash)
|
2005-11-23 21:45:02 +01:00
|
|
|
(void) my_hash_insert(&share->name_hash,
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
(uchar*) field_ptr); // never fail
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
*field_ptr=0; // End marker
|
|
|
|
|
|
|
|
|
|
/* Fix key->name and key_part->field */
|
|
|
|
|
if (key_parts)
|
|
|
|
|
{
|
2004-01-14 13:01:55 +01:00
|
|
|
uint primary_key=(uint) (find_type((char*) primary_key_name,
|
2005-01-06 12:00:13 +01:00
|
|
|
&share->keynames, 3) - 1);
|
2006-11-30 02:40:42 +01:00
|
|
|
longlong ha_option= handler_file->ha_table_flags();
|
2005-11-23 21:45:02 +01:00
|
|
|
keyinfo= share->key_info;
|
|
|
|
|
key_part= keyinfo->key_part;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
for (uint key=0 ; key < share->keys ; key++,keyinfo++)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
uint usable_parts= 0;
|
2005-01-06 12:00:13 +01:00
|
|
|
keyinfo->name=(char*) share->keynames.type_names[key];
|
2002-06-18 23:22:30 +02:00
|
|
|
/* Fix fulltext keys for old .frm files */
|
2005-11-23 21:45:02 +01:00
|
|
|
if (share->key_info[key].flags & HA_FULLTEXT)
|
|
|
|
|
share->key_info[key].algorithm= HA_KEY_ALG_FULLTEXT;
|
2002-06-18 23:22:30 +02:00
|
|
|
|
2006-06-30 23:37:20 +02:00
|
|
|
if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
If the UNIQUE key doesn't have NULL columns and is not a part key
|
|
|
|
|
declare this as a primary key.
|
|
|
|
|
*/
|
|
|
|
|
primary_key=key;
|
|
|
|
|
for (i=0 ; i < keyinfo->key_parts ;i++)
|
|
|
|
|
{
|
|
|
|
|
uint fieldnr= key_part[i].fieldnr;
|
|
|
|
|
if (!fieldnr ||
|
|
|
|
|
share->field[fieldnr-1]->null_ptr ||
|
|
|
|
|
share->field[fieldnr-1]->key_length() !=
|
|
|
|
|
key_part[i].length)
|
|
|
|
|
{
|
|
|
|
|
primary_key=MAX_KEY; // Can't be used
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
for (i=0 ; i < keyinfo->key_parts ; key_part++,i++)
|
|
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
Field *field;
|
2000-07-31 21:29:14 +02:00
|
|
|
if (new_field_pack_flag <= 1)
|
2005-11-23 21:45:02 +01:00
|
|
|
key_part->fieldnr= (uint16) find_field(share->field,
|
2006-11-21 21:32:58 +01:00
|
|
|
share->default_values,
|
2005-11-23 21:45:02 +01:00
|
|
|
(uint) key_part->offset,
|
|
|
|
|
(uint) key_part->length);
|
|
|
|
|
if (!key_part->fieldnr)
|
|
|
|
|
{
|
|
|
|
|
error= 4; // Wrong file
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
field= key_part->field= share->field[key_part->fieldnr-1];
|
2006-11-29 22:07:15 +01:00
|
|
|
key_part->type= field->key_type();
|
2005-11-23 21:45:02 +01:00
|
|
|
if (field->null_ptr)
|
|
|
|
|
{
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
key_part->null_offset=(uint) ((uchar*) field->null_ptr -
|
2005-11-23 21:45:02 +01:00
|
|
|
share->default_values);
|
|
|
|
|
key_part->null_bit= field->null_bit;
|
|
|
|
|
key_part->store_length+=HA_KEY_NULL_LENGTH;
|
|
|
|
|
keyinfo->flags|=HA_NULL_PART_KEY;
|
|
|
|
|
keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
|
|
|
|
|
keyinfo->key_length+= HA_KEY_NULL_LENGTH;
|
|
|
|
|
}
|
2006-12-02 02:26:52 +01:00
|
|
|
if (field->type() == MYSQL_TYPE_BLOB ||
|
2007-10-23 10:44:14 +02:00
|
|
|
field->real_type() == MYSQL_TYPE_VARCHAR ||
|
|
|
|
|
field->type() == MYSQL_TYPE_GEOMETRY)
|
2005-11-23 21:45:02 +01:00
|
|
|
{
|
2007-10-23 10:44:14 +02:00
|
|
|
if (field->type() == MYSQL_TYPE_BLOB ||
|
|
|
|
|
field->type() == MYSQL_TYPE_GEOMETRY)
|
2005-11-23 21:45:02 +01:00
|
|
|
key_part->key_part_flag|= HA_BLOB_PART;
|
|
|
|
|
else
|
|
|
|
|
key_part->key_part_flag|= HA_VAR_LENGTH_PART;
|
|
|
|
|
keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
|
|
|
|
|
key_part->store_length+=HA_KEY_BLOB_LENGTH;
|
|
|
|
|
keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
|
|
|
|
|
/*
|
|
|
|
|
Mark that there may be many matching values for one key
|
|
|
|
|
combination ('a', 'a ', 'a '...)
|
|
|
|
|
*/
|
|
|
|
|
if (!(field->flags & BINARY_FLAG))
|
|
|
|
|
keyinfo->flags|= HA_END_SPACE_KEY;
|
|
|
|
|
}
|
|
|
|
|
if (field->type() == MYSQL_TYPE_BIT)
|
|
|
|
|
key_part->key_part_flag|= HA_BIT_PART;
|
|
|
|
|
|
|
|
|
|
if (i == 0 && key != primary_key)
|
|
|
|
|
field->flags |= (((keyinfo->flags & HA_NOSAME) &&
|
|
|
|
|
(keyinfo->key_parts == 1)) ?
|
|
|
|
|
UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
|
|
|
|
|
if (i == 0)
|
|
|
|
|
field->key_start.set_bit(key);
|
|
|
|
|
if (field->key_length() == key_part->length &&
|
|
|
|
|
!(field->flags & BLOB_FLAG))
|
|
|
|
|
{
|
|
|
|
|
if (handler_file->index_flags(key, i, 0) & HA_KEYREAD_ONLY)
|
|
|
|
|
{
|
|
|
|
|
share->keys_for_keyread.set_bit(key);
|
|
|
|
|
field->part_of_key.set_bit(key);
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
field->part_of_key_not_clustered.set_bit(key);
|
2005-11-23 21:45:02 +01:00
|
|
|
}
|
|
|
|
|
if (handler_file->index_flags(key, i, 1) & HA_READ_ORDER)
|
|
|
|
|
field->part_of_sortkey.set_bit(key);
|
|
|
|
|
}
|
|
|
|
|
if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
|
|
|
|
|
usable_parts == i)
|
|
|
|
|
usable_parts++; // For FILESORT
|
|
|
|
|
field->flags|= PART_KEY_FLAG;
|
|
|
|
|
if (key == primary_key)
|
|
|
|
|
{
|
|
|
|
|
field->flags|= PRI_KEY_FLAG;
|
|
|
|
|
/*
|
|
|
|
|
If this field is part of the primary key and all keys contains
|
|
|
|
|
the primary key, then we can use any key to find this column
|
|
|
|
|
*/
|
|
|
|
|
if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX)
|
2007-07-25 22:23:39 +02:00
|
|
|
{
|
2008-11-29 14:36:17 +01:00
|
|
|
if (field->key_length() == key_part->length &&
|
|
|
|
|
!(field->flags & BLOB_FLAG))
|
|
|
|
|
field->part_of_key= share->keys_in_use;
|
2007-07-27 10:38:11 +02:00
|
|
|
if (field->part_of_sortkey.is_set(key))
|
2007-07-25 22:23:39 +02:00
|
|
|
field->part_of_sortkey= share->keys_in_use;
|
|
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
}
|
|
|
|
|
if (field->key_length() != key_part->length)
|
|
|
|
|
{
|
2005-05-25 17:33:36 +02:00
|
|
|
#ifndef TO_BE_DELETED_ON_PRODUCTION
|
2006-12-02 02:26:52 +01:00
|
|
|
if (field->type() == MYSQL_TYPE_NEWDECIMAL)
|
2005-11-23 21:45:02 +01:00
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
Fix a fatal error in decimal key handling that causes crashes
|
|
|
|
|
on Innodb. We fix it by reducing the key length so that
|
|
|
|
|
InnoDB never gets a too big key when searching.
|
|
|
|
|
This allows the end user to do an ALTER TABLE to fix the
|
|
|
|
|
error.
|
|
|
|
|
*/
|
|
|
|
|
keyinfo->key_length-= (key_part->length - field->key_length());
|
|
|
|
|
key_part->store_length-= (uint16)(key_part->length -
|
|
|
|
|
field->key_length());
|
|
|
|
|
key_part->length= (uint16)field->key_length();
|
|
|
|
|
sql_print_error("Found wrong key definition in %s; "
|
|
|
|
|
"Please do \"ALTER TABLE '%s' FORCE \" to fix it!",
|
|
|
|
|
share->table_name.str,
|
|
|
|
|
share->table_name.str);
|
|
|
|
|
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
|
|
|
|
|
ER_CRASHED_ON_USAGE,
|
|
|
|
|
"Found wrong key definition in %s; "
|
|
|
|
|
"Please do \"ALTER TABLE '%s' FORCE\" to fix "
|
|
|
|
|
"it!",
|
|
|
|
|
share->table_name.str,
|
|
|
|
|
share->table_name.str);
|
|
|
|
|
share->crashed= 1; // Marker for CHECK TABLE
|
|
|
|
|
goto to_be_deleted;
|
|
|
|
|
}
|
2005-05-25 17:33:36 +02:00
|
|
|
#endif
|
2005-11-23 21:45:02 +01:00
|
|
|
key_part->key_part_flag|= HA_PART_KEY_SEG;
|
|
|
|
|
}
|
2005-05-25 17:33:36 +02:00
|
|
|
|
|
|
|
|
to_be_deleted:
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
/*
|
|
|
|
|
If the field can be NULL, don't optimize away the test
|
|
|
|
|
key_part_column = expression from the WHERE clause
|
|
|
|
|
as we need to test for NULL = NULL.
|
|
|
|
|
*/
|
|
|
|
|
if (field->real_maybe_null())
|
2006-10-23 07:32:39 +02:00
|
|
|
key_part->key_part_flag|= HA_NULL_PART;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
keyinfo->usable_key_parts= usable_parts; // Filesort
|
2004-12-31 10:56:50 +01:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
set_if_bigger(share->max_key_length,keyinfo->key_length+
|
2004-12-31 10:56:50 +01:00
|
|
|
keyinfo->key_parts);
|
2005-01-06 12:00:13 +01:00
|
|
|
share->total_key_length+= keyinfo->key_length;
|
2005-05-18 19:40:39 +02:00
|
|
|
/*
|
|
|
|
|
MERGE tables do not have unique indexes. But every key could be
|
|
|
|
|
an unique index on the underlying MyISAM table. (Bug #10400)
|
|
|
|
|
*/
|
|
|
|
|
if ((keyinfo->flags & HA_NOSAME) ||
|
|
|
|
|
(ha_option & HA_ANY_INDEX_MAY_BE_UNIQUE))
|
2005-05-18 22:54:36 +02:00
|
|
|
set_if_bigger(share->max_unique_length,keyinfo->key_length);
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2003-07-28 16:58:52 +02:00
|
|
|
if (primary_key < MAX_KEY &&
|
2005-01-06 12:00:13 +01:00
|
|
|
(share->keys_in_use.is_set(primary_key)))
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2005-01-06 12:00:13 +01:00
|
|
|
share->primary_key= primary_key;
|
2000-10-16 01:29:48 +02:00
|
|
|
/*
|
|
|
|
|
If we are using an integer as the primary key then allow the user to
|
|
|
|
|
refer to it as '_rowid'
|
|
|
|
|
*/
|
2005-11-23 21:45:02 +01:00
|
|
|
if (share->key_info[primary_key].key_parts == 1)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
Field *field= share->key_info[primary_key].key_part[0].field;
|
2000-07-31 21:29:14 +02:00
|
|
|
if (field && field->result_type() == INT_RESULT)
|
2005-11-23 21:45:02 +01:00
|
|
|
{
|
|
|
|
|
/* note that fieldnr here (and rowid_field_offset) starts from 1 */
|
|
|
|
|
share->rowid_field_offset= (share->key_info[primary_key].key_part[0].
|
|
|
|
|
fieldnr);
|
|
|
|
|
}
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
2005-01-06 12:00:13 +01:00
|
|
|
share->primary_key = MAX_KEY; // we do not have a primary key
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2000-10-22 00:19:05 +02:00
|
|
|
else
|
2005-01-06 12:00:13 +01:00
|
|
|
share->primary_key= MAX_KEY;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
x_free((uchar*) disk_buff);
|
2000-10-16 01:29:48 +02:00
|
|
|
disk_buff=0;
|
2000-07-31 21:29:14 +02:00
|
|
|
if (new_field_pack_flag <= 1)
|
2005-01-06 12:00:13 +01:00
|
|
|
{
|
|
|
|
|
/* Old file format with default as not null */
|
|
|
|
|
uint null_length= (share->null_fields+7)/8;
|
2005-11-23 21:45:02 +01:00
|
|
|
bfill(share->default_values + (null_flags - (uchar*) record),
|
2005-01-06 12:00:13 +01:00
|
|
|
null_length, 255);
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
if (share->found_next_number_field)
|
2002-07-23 17:31:22 +02:00
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
reg_field= *share->found_next_number_field;
|
2005-01-06 12:00:13 +01:00
|
|
|
if ((int) (share->next_number_index= (uint)
|
2006-11-21 21:32:58 +01:00
|
|
|
find_ref_key(share->key_info, share->keys,
|
|
|
|
|
share->default_values, reg_field,
|
2007-01-29 10:40:26 +01:00
|
|
|
&share->next_number_key_offset,
|
|
|
|
|
&share->next_number_keypart)) < 0)
|
2002-07-23 17:31:22 +02:00
|
|
|
{
|
2006-11-21 21:32:58 +01:00
|
|
|
/* Wrong field definition */
|
2007-01-29 10:40:26 +01:00
|
|
|
error= 4;
|
|
|
|
|
goto err;
|
2002-07-23 17:31:22 +02:00
|
|
|
}
|
|
|
|
|
else
|
2005-11-23 21:45:02 +01:00
|
|
|
reg_field->flags |= AUTO_INCREMENT_FLAG;
|
2002-07-23 17:31:22 +02:00
|
|
|
}
|
|
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
if (share->blob_fields)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
Field **ptr;
|
2006-12-14 23:51:37 +01:00
|
|
|
uint k, *save;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
/* Store offsets to blob fields to find them fast */
|
|
|
|
|
if (!(share->blob_field= save=
|
2005-11-23 21:45:02 +01:00
|
|
|
(uint*) alloc_root(&share->mem_root,
|
2005-01-06 12:00:13 +01:00
|
|
|
(uint) (share->blob_fields* sizeof(uint)))))
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err;
|
2007-01-27 02:46:45 +01:00
|
|
|
for (k=0, ptr= share->field ; *ptr ; ptr++, k++)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
if ((*ptr)->flags & BLOB_FLAG)
|
2006-12-14 23:51:37 +01:00
|
|
|
(*save++)= k;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-10-08 02:37:23 +02:00
|
|
|
/*
|
|
|
|
|
the correct null_bytes can now be set, since bitfields have been taken
|
|
|
|
|
into account
|
|
|
|
|
*/
|
2005-11-23 21:45:02 +01:00
|
|
|
share->null_bytes= (null_pos - (uchar*) null_flags +
|
2005-10-08 02:37:23 +02:00
|
|
|
(null_bit_pos + 7) / 8);
|
2005-10-04 17:04:20 +02:00
|
|
|
share->last_null_bit_pos= null_bit_pos;
|
2005-09-19 15:52:57 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
share->db_low_byte_first= handler_file->low_byte_first();
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
share->column_bitmap_size= bitmap_buffer_size(share->fields);
|
|
|
|
|
|
|
|
|
|
if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
|
2007-01-29 00:47:35 +01:00
|
|
|
share->column_bitmap_size)))
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
goto err;
|
|
|
|
|
bitmap_init(&share->all_set, bitmaps, share->fields, FALSE);
|
|
|
|
|
bitmap_set_all(&share->all_set);
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
delete handler_file;
|
|
|
|
|
#ifndef DBUG_OFF
|
|
|
|
|
if (use_hash)
|
|
|
|
|
(void) hash_check(&share->name_hash);
|
|
|
|
|
#endif
|
|
|
|
|
DBUG_RETURN (0);
|
|
|
|
|
|
|
|
|
|
err:
|
|
|
|
|
share->error= error;
|
|
|
|
|
share->open_errno= my_errno;
|
|
|
|
|
share->errarg= errarg;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
x_free((uchar*) disk_buff);
|
2005-11-23 21:45:02 +01:00
|
|
|
delete crypted;
|
|
|
|
|
delete handler_file;
|
|
|
|
|
hash_free(&share->name_hash);
|
|
|
|
|
|
|
|
|
|
open_table_error(share, error, share->open_errno, errarg);
|
|
|
|
|
DBUG_RETURN(error);
|
|
|
|
|
} /* open_binary_frm */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Open a table based on a TABLE_SHARE
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
open_table_from_share()
|
|
|
|
|
thd Thread handler
|
|
|
|
|
share Table definition
|
|
|
|
|
alias Alias for table
|
|
|
|
|
db_stat open flags (for example HA_OPEN_KEYFILE|
|
|
|
|
|
HA_OPEN_RNDFILE..) can be 0 (example in
|
|
|
|
|
ha_example_table)
|
|
|
|
|
prgflag READ_ALL etc..
|
|
|
|
|
ha_open_flags HA_OPEN_ABORT_IF_LOCKED etc..
|
|
|
|
|
outparam result table
|
|
|
|
|
|
|
|
|
|
RETURN VALUES
|
|
|
|
|
0 ok
|
|
|
|
|
1 Error (see open_table_error)
|
|
|
|
|
2 Error (see open_table_error)
|
|
|
|
|
3 Wrong data in .frm file
|
|
|
|
|
4 Error (see open_table_error)
|
|
|
|
|
5 Error (see open_table_error: charset unavailable)
|
|
|
|
|
7 Table definition has changed in engine
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
|
|
|
|
|
uint db_stat, uint prgflag, uint ha_open_flags,
|
2006-01-17 08:40:00 +01:00
|
|
|
TABLE *outparam, bool is_create_table)
|
2005-11-23 21:45:02 +01:00
|
|
|
{
|
|
|
|
|
int error;
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
uint records, i, bitmap_size;
|
2005-11-23 21:45:02 +01:00
|
|
|
bool error_reported= FALSE;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
uchar *record, *bitmaps;
|
2005-11-23 21:45:02 +01:00
|
|
|
Field **field_ptr;
|
|
|
|
|
DBUG_ENTER("open_table_from_share");
|
|
|
|
|
DBUG_PRINT("enter",("name: '%s.%s' form: 0x%lx", share->db.str,
|
2006-11-27 00:47:38 +01:00
|
|
|
share->table_name.str, (long) outparam));
|
2005-11-23 21:45:02 +01:00
|
|
|
|
2007-11-05 16:25:40 +01:00
|
|
|
/* Parsing of partitioning information from .frm needs thd->lex set up. */
|
|
|
|
|
DBUG_ASSERT(thd->lex->is_lex_started);
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
error= 1;
|
|
|
|
|
bzero((char*) outparam, sizeof(*outparam));
|
|
|
|
|
outparam->in_use= thd;
|
|
|
|
|
outparam->s= share;
|
|
|
|
|
outparam->db_stat= db_stat;
|
2005-12-22 06:39:02 +01:00
|
|
|
outparam->write_row_record= NULL;
|
2005-11-23 21:45:02 +01:00
|
|
|
|
|
|
|
|
init_sql_alloc(&outparam->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
|
|
|
|
|
|
|
|
|
|
if (!(outparam->alias= my_strdup(alias, MYF(MY_WME))))
|
|
|
|
|
goto err;
|
|
|
|
|
outparam->quick_keys.init();
|
2007-03-05 18:08:41 +01:00
|
|
|
outparam->covering_keys.init();
|
2005-11-23 21:45:02 +01:00
|
|
|
outparam->keys_in_use_for_query.init();
|
|
|
|
|
|
|
|
|
|
/* Allocate handler */
|
2007-08-03 00:14:05 +02:00
|
|
|
outparam->file= 0;
|
|
|
|
|
if (!(prgflag & OPEN_FRM_FILE_ONLY))
|
|
|
|
|
{
|
|
|
|
|
if (!(outparam->file= get_new_handler(share, &outparam->mem_root,
|
|
|
|
|
share->db_type())))
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(!db_stat);
|
|
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
|
|
|
|
|
error= 4;
|
|
|
|
|
outparam->reginfo.lock_type= TL_UNLOCK;
|
|
|
|
|
outparam->current_lock= F_UNLCK;
|
|
|
|
|
records=0;
|
|
|
|
|
if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN))
|
|
|
|
|
records=1;
|
|
|
|
|
if (prgflag & (READ_ALL+EXTRA_RECORD))
|
|
|
|
|
records++;
|
|
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (!(record= (uchar*) alloc_root(&outparam->mem_root,
|
2005-11-23 21:45:02 +01:00
|
|
|
share->rec_buff_length * records)))
|
|
|
|
|
goto err; /* purecov: inspected */
|
|
|
|
|
|
|
|
|
|
if (records == 0)
|
|
|
|
|
{
|
|
|
|
|
/* We are probably in hard repair, and the buffers should not be used */
|
|
|
|
|
outparam->record[0]= outparam->record[1]= share->default_values;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
outparam->record[0]= record;
|
|
|
|
|
if (records > 1)
|
|
|
|
|
outparam->record[1]= record+ share->rec_buff_length;
|
|
|
|
|
else
|
|
|
|
|
outparam->record[1]= outparam->record[0]; // Safety
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_purify
|
|
|
|
|
/*
|
|
|
|
|
We need this because when we read var-length rows, we are not updating
|
|
|
|
|
bytes after end of varchar
|
|
|
|
|
*/
|
|
|
|
|
if (records > 1)
|
|
|
|
|
{
|
|
|
|
|
memcpy(outparam->record[0], share->default_values, share->rec_buff_length);
|
2006-11-30 18:56:34 +01:00
|
|
|
memcpy(outparam->record[1], share->default_values, share->null_bytes);
|
2005-11-23 21:45:02 +01:00
|
|
|
if (records > 2)
|
|
|
|
|
memcpy(outparam->record[1], share->default_values,
|
|
|
|
|
share->rec_buff_length);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root,
|
|
|
|
|
(uint) ((share->fields+1)*
|
|
|
|
|
sizeof(Field*)))))
|
|
|
|
|
goto err; /* purecov: inspected */
|
|
|
|
|
|
|
|
|
|
outparam->field= field_ptr;
|
|
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
record= (uchar*) outparam->record[0]-1; /* Fieldstart = 1 */
|
2005-11-23 21:45:02 +01:00
|
|
|
if (share->null_field_first)
|
|
|
|
|
outparam->null_flags= (uchar*) record+1;
|
|
|
|
|
else
|
|
|
|
|
outparam->null_flags= (uchar*) (record+ 1+ share->reclength -
|
|
|
|
|
share->null_bytes);
|
|
|
|
|
|
|
|
|
|
/* Setup copy of fields from share, but use the right alias and record */
|
|
|
|
|
for (i=0 ; i < share->fields; i++, field_ptr++)
|
|
|
|
|
{
|
|
|
|
|
if (!((*field_ptr)= share->field[i]->clone(&outparam->mem_root, outparam)))
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
(*field_ptr)= 0; // End marker
|
|
|
|
|
|
|
|
|
|
if (share->found_next_number_field)
|
|
|
|
|
outparam->found_next_number_field=
|
|
|
|
|
outparam->field[(uint) (share->found_next_number_field - share->field)];
|
|
|
|
|
if (share->timestamp_field)
|
|
|
|
|
outparam->timestamp_field= (Field_timestamp*) outparam->field[share->timestamp_field_offset];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Fix key->name and key_part->field */
|
|
|
|
|
if (share->key_parts)
|
|
|
|
|
{
|
|
|
|
|
KEY *key_info, *key_info_end;
|
|
|
|
|
KEY_PART_INFO *key_part;
|
|
|
|
|
uint n_length;
|
|
|
|
|
n_length= share->keys*sizeof(KEY) + share->key_parts*sizeof(KEY_PART_INFO);
|
|
|
|
|
if (!(key_info= (KEY*) alloc_root(&outparam->mem_root, n_length)))
|
|
|
|
|
goto err;
|
|
|
|
|
outparam->key_info= key_info;
|
|
|
|
|
key_part= (my_reinterpret_cast(KEY_PART_INFO*) (key_info+share->keys));
|
|
|
|
|
|
|
|
|
|
memcpy(key_info, share->key_info, sizeof(*key_info)*share->keys);
|
|
|
|
|
memcpy(key_part, share->key_info[0].key_part, (sizeof(*key_part) *
|
|
|
|
|
share->key_parts));
|
|
|
|
|
|
|
|
|
|
for (key_info_end= key_info + share->keys ;
|
|
|
|
|
key_info < key_info_end ;
|
|
|
|
|
key_info++)
|
|
|
|
|
{
|
|
|
|
|
KEY_PART_INFO *key_part_end;
|
|
|
|
|
|
|
|
|
|
key_info->table= outparam;
|
|
|
|
|
key_info->key_part= key_part;
|
|
|
|
|
|
|
|
|
|
for (key_part_end= key_part+ key_info->key_parts ;
|
|
|
|
|
key_part < key_part_end ;
|
|
|
|
|
key_part++)
|
|
|
|
|
{
|
|
|
|
|
Field *field= key_part->field= outparam->field[key_part->fieldnr-1];
|
|
|
|
|
|
|
|
|
|
if (field->key_length() != key_part->length &&
|
|
|
|
|
!(field->flags & BLOB_FLAG))
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
We are using only a prefix of the column as a key:
|
|
|
|
|
Create a new field for the key part that matches the index
|
|
|
|
|
*/
|
|
|
|
|
field= key_part->field=field->new_field(&outparam->mem_root,
|
2006-07-06 20:12:33 +02:00
|
|
|
outparam, 0);
|
2005-11-23 21:45:02 +01:00
|
|
|
field->field_length= key_part->length;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef WITH_PARTITION_STORAGE_ENGINE
|
2007-08-09 19:05:56 +02:00
|
|
|
if (share->partition_info_len && outparam->file)
|
2005-11-23 21:45:02 +01:00
|
|
|
{
|
2006-08-22 22:52:25 +02:00
|
|
|
/*
|
|
|
|
|
In this execution we must avoid calling thd->change_item_tree since
|
|
|
|
|
we might release memory before statement is completed. We do this
|
|
|
|
|
by changing to a new statement arena. As part of this arena we also
|
|
|
|
|
set the memory root to be the memory root of the table since we
|
|
|
|
|
call the parser and fix_fields which both can allocate memory for
|
|
|
|
|
item objects. We keep the arena to ensure that we can release the
|
|
|
|
|
free_list when closing the table object.
|
|
|
|
|
SEE Bug #21658
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
Query_arena *backup_stmt_arena_ptr= thd->stmt_arena;
|
|
|
|
|
Query_arena backup_arena;
|
|
|
|
|
Query_arena part_func_arena(&outparam->mem_root, Query_arena::INITIALIZED);
|
|
|
|
|
thd->set_n_backup_active_arena(&part_func_arena, &backup_arena);
|
|
|
|
|
thd->stmt_arena= &part_func_arena;
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
bool tmp;
|
2007-03-27 13:15:38 +02:00
|
|
|
bool work_part_info_used;
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
|
2006-06-04 20:05:22 +02:00
|
|
|
tmp= mysql_unpack_partition(thd, share->partition_info,
|
|
|
|
|
share->partition_info_len,
|
2007-03-27 19:09:56 +02:00
|
|
|
share->part_state,
|
2006-06-04 20:05:22 +02:00
|
|
|
share->part_state_len,
|
|
|
|
|
outparam, is_create_table,
|
2007-03-27 13:15:38 +02:00
|
|
|
share->default_part_db_type,
|
|
|
|
|
&work_part_info_used);
|
2007-11-19 09:42:25 +01:00
|
|
|
if (tmp)
|
|
|
|
|
{
|
|
|
|
|
thd->stmt_arena= backup_stmt_arena_ptr;
|
|
|
|
|
thd->restore_active_arena(&part_func_arena, &backup_arena);
|
|
|
|
|
goto partititon_err;
|
|
|
|
|
}
|
|
|
|
|
outparam->part_info->is_auto_partitioned= share->auto_partitioned;
|
2006-06-04 20:05:22 +02:00
|
|
|
DBUG_PRINT("info", ("autopartitioned: %u", share->auto_partitioned));
|
2007-03-27 13:15:38 +02:00
|
|
|
/* we should perform the fix_partition_func in either local or
|
|
|
|
|
caller's arena depending on work_part_info_used value
|
|
|
|
|
*/
|
2007-11-19 09:42:25 +01:00
|
|
|
if (!work_part_info_used)
|
2006-06-14 15:12:07 +02:00
|
|
|
tmp= fix_partition_func(thd, outparam, is_create_table);
|
2006-08-22 22:52:25 +02:00
|
|
|
thd->stmt_arena= backup_stmt_arena_ptr;
|
|
|
|
|
thd->restore_active_arena(&part_func_arena, &backup_arena);
|
2006-08-31 10:16:22 +02:00
|
|
|
if (!tmp)
|
2007-03-27 13:15:38 +02:00
|
|
|
{
|
|
|
|
|
if (work_part_info_used)
|
|
|
|
|
tmp= fix_partition_func(thd, outparam, is_create_table);
|
2006-08-31 10:16:22 +02:00
|
|
|
outparam->part_info->item_free_list= part_func_arena.free_list;
|
2007-03-27 13:15:38 +02:00
|
|
|
}
|
2007-11-19 09:42:25 +01:00
|
|
|
partititon_err:
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
if (tmp)
|
2006-06-20 19:24:30 +02:00
|
|
|
{
|
|
|
|
|
if (is_create_table)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
During CREATE/ALTER TABLE it is ok to receive errors here.
|
|
|
|
|
It is not ok if it happens during the opening of an frm
|
|
|
|
|
file as part of a normal query.
|
|
|
|
|
*/
|
|
|
|
|
error_reported= TRUE;
|
|
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
goto err;
|
2006-06-20 19:24:30 +02:00
|
|
|
}
|
2005-11-23 21:45:02 +01:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
/* Allocate bitmaps */
|
|
|
|
|
|
|
|
|
|
bitmap_size= share->column_bitmap_size;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (!(bitmaps= (uchar*) alloc_root(&outparam->mem_root, bitmap_size*3)))
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
goto err;
|
|
|
|
|
bitmap_init(&outparam->def_read_set,
|
|
|
|
|
(my_bitmap_map*) bitmaps, share->fields, FALSE);
|
|
|
|
|
bitmap_init(&outparam->def_write_set,
|
|
|
|
|
(my_bitmap_map*) (bitmaps+bitmap_size), share->fields, FALSE);
|
|
|
|
|
bitmap_init(&outparam->tmp_set,
|
|
|
|
|
(my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields, FALSE);
|
|
|
|
|
outparam->default_column_bitmaps();
|
|
|
|
|
|
2004-10-07 00:45:06 +02:00
|
|
|
/* The table struct is now initialized; Open the table */
|
2005-11-23 21:45:02 +01:00
|
|
|
error= 2;
|
2000-10-16 01:29:48 +02:00
|
|
|
if (db_stat)
|
|
|
|
|
{
|
2005-01-13 02:02:49 +01:00
|
|
|
int ha_err;
|
|
|
|
|
if ((ha_err= (outparam->file->
|
2005-11-23 21:45:02 +01:00
|
|
|
ha_open(outparam, share->normalized_path.str,
|
2005-01-13 02:02:49 +01:00
|
|
|
(db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
|
|
|
|
|
(db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE :
|
|
|
|
|
((db_stat & HA_WAIT_IF_LOCKED) ||
|
|
|
|
|
(specialflag & SPECIAL_WAIT_IF_LOCKED)) ?
|
|
|
|
|
HA_OPEN_WAIT_IF_LOCKED :
|
|
|
|
|
(db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO)) ?
|
|
|
|
|
HA_OPEN_ABORT_IF_LOCKED :
|
|
|
|
|
HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
|
2000-10-16 01:29:48 +02:00
|
|
|
{
|
|
|
|
|
/* Set a flag if the table is crashed and it can be auto. repaired */
|
2005-01-13 02:02:49 +01:00
|
|
|
share->crashed= ((ha_err == HA_ERR_CRASHED_ON_USAGE) &&
|
2005-01-06 12:00:13 +01:00
|
|
|
outparam->file->auto_repair() &&
|
|
|
|
|
!(ha_open_flags & HA_OPEN_FOR_REPAIR));
|
2004-09-13 14:46:38 +02:00
|
|
|
|
2006-11-28 04:14:36 +01:00
|
|
|
switch (ha_err)
|
2004-09-13 14:46:38 +02:00
|
|
|
{
|
2006-11-28 04:14:36 +01:00
|
|
|
case HA_ERR_NO_SUCH_TABLE:
|
|
|
|
|
/*
|
|
|
|
|
The table did not exists in storage engine, use same error message
|
|
|
|
|
as if the .frm file didn't exist
|
|
|
|
|
*/
|
|
|
|
|
error= 1;
|
|
|
|
|
my_errno= ENOENT;
|
|
|
|
|
break;
|
|
|
|
|
case EMFILE:
|
|
|
|
|
/*
|
|
|
|
|
Too many files opened, use same error message as if the .frm
|
|
|
|
|
file can't open
|
|
|
|
|
*/
|
|
|
|
|
DBUG_PRINT("error", ("open file: %s failed, too many files opened (errno: %d)",
|
|
|
|
|
share->normalized_path.str, ha_err));
|
|
|
|
|
error= 1;
|
|
|
|
|
my_errno= EMFILE;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
outparam->file->print_error(ha_err, MYF(0));
|
|
|
|
|
error_reported= TRUE;
|
|
|
|
|
if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
|
|
|
|
|
error= 7;
|
|
|
|
|
break;
|
2004-12-23 20:11:38 +01:00
|
|
|
}
|
2005-01-13 02:02:49 +01:00
|
|
|
goto err; /* purecov: inspected */
|
2000-10-16 01:29:48 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
#if defined(HAVE_purify) && !defined(DBUG_OFF)
|
|
|
|
|
bzero((char*) bitmaps, bitmap_size*3);
|
|
|
|
|
#endif
|
|
|
|
|
|
2007-08-03 22:02:19 +02:00
|
|
|
outparam->no_replicate= outparam->file &&
|
|
|
|
|
test(outparam->file->ha_table_flags() &
|
2007-08-03 00:14:27 +02:00
|
|
|
HA_HAS_OWN_BINLOGGING);
|
2004-09-17 02:08:23 +02:00
|
|
|
thd->status_var.opened_tables++;
|
2005-12-22 06:39:02 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_RETURN (0);
|
|
|
|
|
|
2005-01-13 02:02:49 +01:00
|
|
|
err:
|
2004-12-23 20:11:38 +01:00
|
|
|
if (! error_reported)
|
2005-11-23 21:45:02 +01:00
|
|
|
open_table_error(share, error, my_errno, 0);
|
2000-10-10 23:06:37 +02:00
|
|
|
delete outparam->file;
|
2005-11-07 16:25:06 +01:00
|
|
|
#ifdef WITH_PARTITION_STORAGE_ENGINE
|
2005-11-23 21:45:02 +01:00
|
|
|
if (outparam->part_info)
|
|
|
|
|
free_items(outparam->part_info->item_free_list);
|
2005-07-18 13:31:02 +02:00
|
|
|
#endif
|
2005-11-23 21:45:02 +01:00
|
|
|
outparam->file= 0; // For easier error checking
|
2000-11-21 02:43:34 +01:00
|
|
|
outparam->db_stat=0;
|
2005-01-13 02:02:49 +01:00
|
|
|
free_root(&outparam->mem_root, MYF(0)); // Safe to call on bzero'd root
|
2005-01-06 12:00:13 +01:00
|
|
|
my_free((char*) outparam->alias, MYF(MY_ALLOW_ZERO_PTR));
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_RETURN (error);
|
2005-11-23 21:45:02 +01:00
|
|
|
}
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2006-03-29 13:27:36 +02:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Free information allocated by openfrm
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
closefrm()
|
|
|
|
|
table TABLE object to free
|
|
|
|
|
free_share Is 1 if we also want to free table_share
|
|
|
|
|
*/
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
int closefrm(register TABLE *table, bool free_share)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
int error=0;
|
2005-11-06 13:13:06 +01:00
|
|
|
uint idx;
|
|
|
|
|
KEY *key_info;
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_ENTER("closefrm");
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
DBUG_PRINT("enter", ("table: 0x%lx", (long) table));
|
2006-03-29 13:27:36 +02:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
if (table->db_stat)
|
|
|
|
|
error=table->file->close();
|
2005-11-06 13:13:06 +01:00
|
|
|
key_info= table->key_info;
|
|
|
|
|
for (idx= table->s->keys; idx; idx--, key_info++)
|
|
|
|
|
{
|
|
|
|
|
if (key_info->flags & HA_USES_PARSER)
|
2005-11-06 14:26:37 +01:00
|
|
|
{
|
2007-03-02 17:43:45 +01:00
|
|
|
plugin_unlock(NULL, key_info->parser);
|
2005-11-06 14:26:37 +01:00
|
|
|
key_info->flags= 0;
|
|
|
|
|
}
|
2005-11-06 13:13:06 +01:00
|
|
|
}
|
2005-01-06 12:00:13 +01:00
|
|
|
my_free((char*) table->alias, MYF(MY_ALLOW_ZERO_PTR));
|
|
|
|
|
table->alias= 0;
|
|
|
|
|
if (table->field)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
for (Field **ptr=table->field ; *ptr ; ptr++)
|
|
|
|
|
delete *ptr;
|
2005-01-06 12:00:13 +01:00
|
|
|
table->field= 0;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
delete table->file;
|
2005-11-23 21:45:02 +01:00
|
|
|
table->file= 0; /* For easier errorchecking */
|
2005-11-07 16:25:06 +01:00
|
|
|
#ifdef WITH_PARTITION_STORAGE_ENGINE
|
2005-11-23 21:45:02 +01:00
|
|
|
if (table->part_info)
|
2005-07-18 13:31:02 +02:00
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
free_items(table->part_info->item_free_list);
|
2006-01-17 08:40:00 +01:00
|
|
|
table->part_info->item_free_list= 0;
|
2005-11-23 21:45:02 +01:00
|
|
|
table->part_info= 0;
|
2005-07-18 13:31:02 +02:00
|
|
|
}
|
|
|
|
|
#endif
|
2005-11-23 21:45:02 +01:00
|
|
|
if (free_share)
|
|
|
|
|
{
|
|
|
|
|
if (table->s->tmp_table == NO_TMP_TABLE)
|
|
|
|
|
release_table_share(table->s, RELEASE_NORMAL);
|
|
|
|
|
else
|
|
|
|
|
free_table_share(table->s);
|
|
|
|
|
}
|
2005-01-06 12:00:13 +01:00
|
|
|
free_root(&table->mem_root, MYF(0));
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_RETURN(error);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Deallocate temporary blob storage */
|
|
|
|
|
|
|
|
|
|
void free_blobs(register TABLE *table)
|
|
|
|
|
{
|
2005-01-06 12:00:13 +01:00
|
|
|
uint *ptr, *end;
|
|
|
|
|
for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ;
|
|
|
|
|
ptr != end ;
|
|
|
|
|
ptr++)
|
|
|
|
|
((Field_blob*) table->field[*ptr])->free();
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-07-24 22:38:44 +02:00
|
|
|
/**
|
|
|
|
|
Reclaim temporary blob storage which is bigger than
|
|
|
|
|
a threshold.
|
|
|
|
|
|
|
|
|
|
@param table A handle to the TABLE object containing blob fields
|
|
|
|
|
@param size The threshold value.
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void free_field_buffers_larger_than(TABLE *table, uint32 size)
|
|
|
|
|
{
|
|
|
|
|
uint *ptr, *end;
|
|
|
|
|
for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ;
|
|
|
|
|
ptr != end ;
|
|
|
|
|
ptr++)
|
|
|
|
|
{
|
|
|
|
|
Field_blob *blob= (Field_blob*) table->field[*ptr];
|
|
|
|
|
if (blob->get_field_buffer_size() > size)
|
|
|
|
|
blob->free();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
/* Find where a form starts */
|
|
|
|
|
/* if formname is NullS then only formnames is read */
|
|
|
|
|
|
|
|
|
|
ulong get_form_pos(File file, uchar *head, TYPELIB *save_names)
|
|
|
|
|
{
|
|
|
|
|
uint a_length,names,length;
|
|
|
|
|
uchar *pos,*buf;
|
|
|
|
|
ulong ret_value=0;
|
|
|
|
|
DBUG_ENTER("get_form_pos");
|
|
|
|
|
|
|
|
|
|
names=uint2korr(head+8);
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
a_length=(names+2)*sizeof(char *); /* Room for two extra */
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
if (!save_names)
|
|
|
|
|
a_length=0;
|
|
|
|
|
else
|
|
|
|
|
save_names->type_names=0; /* Clear if error */
|
|
|
|
|
|
|
|
|
|
if (names)
|
|
|
|
|
{
|
|
|
|
|
length=uint2korr(head+4);
|
|
|
|
|
VOID(my_seek(file,64L,MY_SEEK_SET,MYF(0)));
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (!(buf= (uchar*) my_malloc((size_t) length+a_length+names*4,
|
2000-07-31 21:29:14 +02:00
|
|
|
MYF(MY_WME))) ||
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
my_read(file, buf+a_length, (size_t) (length+names*4),
|
2000-07-31 21:29:14 +02:00
|
|
|
MYF(MY_NABP)))
|
|
|
|
|
{ /* purecov: inspected */
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
x_free((uchar*) buf); /* purecov: inspected */
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_RETURN(0L); /* purecov: inspected */
|
|
|
|
|
}
|
|
|
|
|
pos= buf+a_length+length;
|
|
|
|
|
ret_value=uint4korr(pos);
|
|
|
|
|
}
|
|
|
|
|
if (! save_names)
|
2006-01-03 17:54:54 +01:00
|
|
|
{
|
|
|
|
|
if (names)
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
my_free((uchar*) buf,MYF(0));
|
2006-01-03 17:54:54 +01:00
|
|
|
}
|
2000-07-31 21:29:14 +02:00
|
|
|
else if (!names)
|
|
|
|
|
bzero((char*) save_names,sizeof(save_names));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
char *str;
|
|
|
|
|
str=(char *) (buf+a_length);
|
|
|
|
|
fix_type_pointers((const char ***) &buf,save_names,1,&str);
|
|
|
|
|
}
|
|
|
|
|
DBUG_RETURN(ret_value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
/*
|
|
|
|
|
Read string from a file with malloc
|
2000-07-31 21:29:14 +02:00
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
NOTES:
|
|
|
|
|
We add an \0 at end of the read string to make reading of C strings easier
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int read_string(File file, uchar**to, size_t length)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
DBUG_ENTER("read_string");
|
|
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
x_free(*to);
|
|
|
|
|
if (!(*to= (uchar*) my_malloc(length+1,MYF(MY_WME))) ||
|
|
|
|
|
my_read(file, *to, length,MYF(MY_NABP)))
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
x_free(*to); /* purecov: inspected */
|
|
|
|
|
*to= 0; /* purecov: inspected */
|
|
|
|
|
DBUG_RETURN(1); /* purecov: inspected */
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
*((char*) *to+length)= '\0';
|
|
|
|
|
DBUG_RETURN (0);
|
|
|
|
|
} /* read_string */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Add a new form to a form file */
|
|
|
|
|
|
|
|
|
|
ulong make_new_entry(File file, uchar *fileinfo, TYPELIB *formnames,
|
|
|
|
|
const char *newname)
|
|
|
|
|
{
|
|
|
|
|
uint i,bufflength,maxlength,n_length,length,names;
|
|
|
|
|
ulong endpos,newpos;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
uchar buff[IO_SIZE];
|
2000-07-31 21:29:14 +02:00
|
|
|
uchar *pos;
|
|
|
|
|
DBUG_ENTER("make_new_entry");
|
|
|
|
|
|
2000-08-21 23:18:32 +02:00
|
|
|
length=(uint) strlen(newname)+1;
|
2000-07-31 21:29:14 +02:00
|
|
|
n_length=uint2korr(fileinfo+4);
|
|
|
|
|
maxlength=uint2korr(fileinfo+6);
|
|
|
|
|
names=uint2korr(fileinfo+8);
|
|
|
|
|
newpos=uint4korr(fileinfo+10);
|
|
|
|
|
|
|
|
|
|
if (64+length+n_length+(names+1)*4 > maxlength)
|
|
|
|
|
{ /* Expand file */
|
|
|
|
|
newpos+=IO_SIZE;
|
|
|
|
|
int4store(fileinfo+10,newpos);
|
2000-08-21 23:18:32 +02:00
|
|
|
endpos=(ulong) my_seek(file,0L,MY_SEEK_END,MYF(0));/* Copy from file-end */
|
2000-07-31 21:29:14 +02:00
|
|
|
bufflength= (uint) (endpos & (IO_SIZE-1)); /* IO_SIZE is a power of 2 */
|
|
|
|
|
|
|
|
|
|
while (endpos > maxlength)
|
|
|
|
|
{
|
|
|
|
|
VOID(my_seek(file,(ulong) (endpos-bufflength),MY_SEEK_SET,MYF(0)));
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (my_read(file, buff, bufflength, MYF(MY_NABP+MY_WME)))
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_RETURN(0L);
|
|
|
|
|
VOID(my_seek(file,(ulong) (endpos-bufflength+IO_SIZE),MY_SEEK_SET,
|
|
|
|
|
MYF(0)));
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if ((my_write(file, buff,bufflength,MYF(MY_NABP+MY_WME))))
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_RETURN(0);
|
|
|
|
|
endpos-=bufflength; bufflength=IO_SIZE;
|
|
|
|
|
}
|
|
|
|
|
bzero(buff,IO_SIZE); /* Null new block */
|
|
|
|
|
VOID(my_seek(file,(ulong) maxlength,MY_SEEK_SET,MYF(0)));
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (my_write(file,buff,bufflength,MYF(MY_NABP+MY_WME)))
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_RETURN(0L);
|
|
|
|
|
maxlength+=IO_SIZE; /* Fix old ref */
|
|
|
|
|
int2store(fileinfo+6,maxlength);
|
|
|
|
|
for (i=names, pos= (uchar*) *formnames->type_names+n_length-1; i-- ;
|
|
|
|
|
pos+=4)
|
|
|
|
|
{
|
|
|
|
|
endpos=uint4korr(pos)+IO_SIZE;
|
|
|
|
|
int4store(pos,endpos);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (n_length == 1 )
|
|
|
|
|
{ /* First name */
|
|
|
|
|
length++;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
VOID(strxmov((char*) buff,"/",newname,"/",NullS));
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
else
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
VOID(strxmov((char*) buff,newname,"/",NullS)); /* purecov: inspected */
|
2000-07-31 21:29:14 +02:00
|
|
|
VOID(my_seek(file,63L+(ulong) n_length,MY_SEEK_SET,MYF(0)));
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (my_write(file, buff, (size_t) length+1,MYF(MY_NABP+MY_WME)) ||
|
|
|
|
|
(names && my_write(file,(uchar*) (*formnames->type_names+n_length-1),
|
2000-07-31 21:29:14 +02:00
|
|
|
names*4, MYF(MY_NABP+MY_WME))) ||
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
my_write(file, fileinfo+10, 4,MYF(MY_NABP+MY_WME)))
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_RETURN(0L); /* purecov: inspected */
|
|
|
|
|
|
|
|
|
|
int2store(fileinfo+8,names+1);
|
|
|
|
|
int2store(fileinfo+4,n_length+length);
|
2002-08-08 02:12:02 +02:00
|
|
|
VOID(my_chsize(file, newpos, 0, MYF(MY_WME)));/* Append file with '\0' */
|
2000-07-31 21:29:14 +02:00
|
|
|
DBUG_RETURN(newpos);
|
|
|
|
|
} /* make_new_entry */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* error message when opening a form file */
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
int err_no;
|
|
|
|
|
char buff[FN_REFLEN];
|
2005-11-23 21:45:02 +01:00
|
|
|
myf errortype= ME_ERROR+ME_WAITTANG;
|
|
|
|
|
DBUG_ENTER("open_table_error");
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
switch (error) {
|
2005-11-23 21:45:02 +01:00
|
|
|
case 7:
|
2000-07-31 21:29:14 +02:00
|
|
|
case 1:
|
2005-11-23 21:45:02 +01:00
|
|
|
if (db_errno == ENOENT)
|
|
|
|
|
my_error(ER_NO_SUCH_TABLE, MYF(0), share->db.str, share->table_name.str);
|
|
|
|
|
else
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
strxmov(buff, share->normalized_path.str, reg_ext, NullS);
|
2006-01-19 11:43:19 +01:00
|
|
|
my_error((db_errno == EMFILE) ? ER_CANT_OPEN_FILE : ER_FILE_NOT_FOUND,
|
|
|
|
|
errortype, buff, db_errno);
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
{
|
2005-11-23 21:45:02 +01:00
|
|
|
handler *file= 0;
|
|
|
|
|
const char *datext= "";
|
|
|
|
|
|
2007-03-02 17:43:45 +01:00
|
|
|
if (share->db_type() != NULL)
|
2005-11-23 21:45:02 +01:00
|
|
|
{
|
|
|
|
|
if ((file= get_new_handler(share, current_thd->mem_root,
|
2007-03-02 17:43:45 +01:00
|
|
|
share->db_type())))
|
2005-11-23 21:45:02 +01:00
|
|
|
{
|
|
|
|
|
if (!(datext= *file->bas_ext()))
|
|
|
|
|
datext= "";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
err_no= (db_errno == ENOENT) ? ER_FILE_NOT_FOUND : (db_errno == EAGAIN) ?
|
2000-07-31 21:29:14 +02:00
|
|
|
ER_FILE_USED : ER_CANT_OPEN_FILE;
|
2005-11-23 21:45:02 +01:00
|
|
|
strxmov(buff, share->normalized_path.str, datext, NullS);
|
|
|
|
|
my_error(err_no,errortype, buff, db_errno);
|
|
|
|
|
delete file;
|
2000-07-31 21:29:14 +02:00
|
|
|
break;
|
|
|
|
|
}
|
2004-12-22 15:56:57 +01:00
|
|
|
case 5:
|
|
|
|
|
{
|
|
|
|
|
const char *csname= get_charset_name((uint) errarg);
|
|
|
|
|
char tmp[10];
|
|
|
|
|
if (!csname || csname[0] =='?')
|
|
|
|
|
{
|
|
|
|
|
my_snprintf(tmp, sizeof(tmp), "#%d", errarg);
|
|
|
|
|
csname= tmp;
|
|
|
|
|
}
|
|
|
|
|
my_printf_error(ER_UNKNOWN_COLLATION,
|
|
|
|
|
"Unknown collation '%s' in table '%-.64s' definition",
|
2005-11-23 21:45:02 +01:00
|
|
|
MYF(0), csname, share->table_name.str);
|
2000-07-31 21:29:14 +02:00
|
|
|
break;
|
|
|
|
|
}
|
2005-05-07 22:57:22 +02:00
|
|
|
case 6:
|
2005-11-23 21:45:02 +01:00
|
|
|
strxmov(buff, share->normalized_path.str, reg_ext, NullS);
|
2005-05-07 22:57:22 +02:00
|
|
|
my_printf_error(ER_NOT_FORM_FILE,
|
|
|
|
|
"Table '%-.64s' was created with a different version "
|
2005-11-23 21:45:02 +01:00
|
|
|
"of MySQL and cannot be read",
|
|
|
|
|
MYF(0), buff);
|
2005-05-07 22:57:22 +02:00
|
|
|
break;
|
2007-12-14 14:05:27 +01:00
|
|
|
case 8:
|
|
|
|
|
break;
|
2000-07-31 21:29:14 +02:00
|
|
|
default: /* Better wrong error than none */
|
|
|
|
|
case 4:
|
2005-11-23 21:45:02 +01:00
|
|
|
strxmov(buff, share->normalized_path.str, reg_ext, NullS);
|
|
|
|
|
my_error(ER_NOT_FORM_FILE, errortype, buff, 0);
|
2000-07-31 21:29:14 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
DBUG_VOID_RETURN;
|
2005-11-23 21:45:02 +01:00
|
|
|
} /* open_table_error */
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** fix a str_type to a array type
|
2004-10-07 00:45:06 +02:00
|
|
|
** typeparts separated with some char. differents types are separated
|
2000-07-31 21:29:14 +02:00
|
|
|
** with a '\0'
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
fix_type_pointers(const char ***array, TYPELIB *point_to_type, uint types,
|
|
|
|
|
char **names)
|
|
|
|
|
{
|
|
|
|
|
char *type_name, *ptr;
|
|
|
|
|
char chr;
|
|
|
|
|
|
|
|
|
|
ptr= *names;
|
|
|
|
|
while (types--)
|
|
|
|
|
{
|
|
|
|
|
point_to_type->name=0;
|
|
|
|
|
point_to_type->type_names= *array;
|
|
|
|
|
|
|
|
|
|
if ((chr= *ptr)) /* Test if empty type */
|
|
|
|
|
{
|
|
|
|
|
while ((type_name=strchr(ptr+1,chr)) != NullS)
|
|
|
|
|
{
|
|
|
|
|
*((*array)++) = ptr+1;
|
|
|
|
|
*type_name= '\0'; /* End string */
|
|
|
|
|
ptr=type_name;
|
|
|
|
|
}
|
2001-11-06 23:13:29 +01:00
|
|
|
ptr+=2; /* Skip end mark and last 0 */
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
ptr++;
|
|
|
|
|
point_to_type->count= (uint) (*array - point_to_type->type_names);
|
|
|
|
|
point_to_type++;
|
|
|
|
|
*((*array)++)= NullS; /* End of type */
|
|
|
|
|
}
|
|
|
|
|
*names=ptr; /* Update end */
|
|
|
|
|
return;
|
|
|
|
|
} /* fix_type_pointers */
|
|
|
|
|
|
|
|
|
|
|
2005-11-25 11:25:31 +01:00
|
|
|
TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2005-11-25 11:25:31 +01:00
|
|
|
TYPELIB *result= (TYPELIB*) alloc_root(mem_root, sizeof(TYPELIB));
|
2000-07-31 21:29:14 +02:00
|
|
|
if (!result)
|
|
|
|
|
return 0;
|
|
|
|
|
result->count=strings.elements;
|
|
|
|
|
result->name="";
|
2004-10-25 14:51:26 +02:00
|
|
|
uint nbytes= (sizeof(char*) + sizeof(uint)) * (result->count + 1);
|
2005-11-25 11:25:31 +01:00
|
|
|
if (!(result->type_names= (const char**) alloc_root(mem_root, nbytes)))
|
2000-07-31 21:29:14 +02:00
|
|
|
return 0;
|
2004-10-25 14:51:26 +02:00
|
|
|
result->type_lengths= (uint*) (result->type_names + result->count + 1);
|
2000-07-31 21:29:14 +02:00
|
|
|
List_iterator<String> it(strings);
|
|
|
|
|
String *tmp;
|
|
|
|
|
for (uint i=0; (tmp=it++) ; i++)
|
2004-10-25 14:51:26 +02:00
|
|
|
{
|
|
|
|
|
result->type_names[i]= tmp->ptr();
|
|
|
|
|
result->type_lengths[i]= tmp->length();
|
|
|
|
|
}
|
|
|
|
|
result->type_names[result->count]= 0; // End marker
|
|
|
|
|
result->type_lengths[result->count]= 0;
|
2000-07-31 21:29:14 +02:00
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-01-06 12:00:13 +01:00
|
|
|
/*
|
|
|
|
|
Search after a field with given start & length
|
|
|
|
|
If an exact field isn't found, return longest field with starts
|
|
|
|
|
at right position.
|
|
|
|
|
|
|
|
|
|
NOTES
|
|
|
|
|
This is needed because in some .frm fields 'fieldnr' was saved wrong
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
0 error
|
|
|
|
|
# field number +1
|
|
|
|
|
*/
|
2000-07-31 21:29:14 +02:00
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
static uint find_field(Field **fields, uchar *record, uint start, uint length)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
Field **field;
|
2005-11-23 21:45:02 +01:00
|
|
|
uint i, pos;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
pos= 0;
|
|
|
|
|
for (field= fields, i=1 ; *field ; i++,field++)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2006-11-21 21:32:58 +01:00
|
|
|
if ((*field)->offset(record) == start)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
if ((*field)->key_length() == length)
|
|
|
|
|
return (i);
|
2005-11-23 21:45:02 +01:00
|
|
|
if (!pos || fields[pos-1]->pack_length() <
|
2000-07-31 21:29:14 +02:00
|
|
|
(*field)->pack_length())
|
2005-11-23 21:45:02 +01:00
|
|
|
pos= i;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return (pos);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-10-07 00:45:06 +02:00
|
|
|
/* Check that the integer is in the internal */
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
int set_zone(register int nr, int min_zone, int max_zone)
|
|
|
|
|
{
|
|
|
|
|
if (nr<=min_zone)
|
|
|
|
|
return (min_zone);
|
|
|
|
|
if (nr>=max_zone)
|
|
|
|
|
return (max_zone);
|
|
|
|
|
return (nr);
|
|
|
|
|
} /* set_zone */
|
|
|
|
|
|
|
|
|
|
/* Adjust number to next larger disk buffer */
|
|
|
|
|
|
|
|
|
|
ulong next_io_size(register ulong pos)
|
|
|
|
|
{
|
|
|
|
|
reg2 ulong offset;
|
|
|
|
|
if ((offset= pos & (IO_SIZE-1)))
|
|
|
|
|
return pos-offset+IO_SIZE;
|
|
|
|
|
return pos;
|
|
|
|
|
} /* next_io_size */
|
|
|
|
|
|
|
|
|
|
|
2003-12-16 14:39:33 +01:00
|
|
|
/*
|
|
|
|
|
Store an SQL quoted string.
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
append_unescaped()
|
|
|
|
|
res result String
|
|
|
|
|
pos string to be quoted
|
|
|
|
|
length it's length
|
|
|
|
|
|
|
|
|
|
NOTE
|
|
|
|
|
This function works correctly with utf8 or single-byte charset strings.
|
|
|
|
|
May fail with some multibyte charsets though.
|
|
|
|
|
*/
|
2002-06-02 20:22:20 +02:00
|
|
|
|
2003-12-16 14:39:33 +01:00
|
|
|
void append_unescaped(String *res, const char *pos, uint length)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2002-06-02 20:22:20 +02:00
|
|
|
const char *end= pos+length;
|
|
|
|
|
res->append('\'');
|
|
|
|
|
|
|
|
|
|
for (; pos != end ; pos++)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2004-08-27 23:49:54 +02:00
|
|
|
#if defined(USE_MB) && MYSQL_VERSION_ID < 40100
|
2004-08-27 09:09:28 +02:00
|
|
|
uint mblen;
|
|
|
|
|
if (use_mb(default_charset_info) &&
|
|
|
|
|
(mblen= my_ismbchar(default_charset_info, pos, end)))
|
|
|
|
|
{
|
|
|
|
|
res->append(pos, mblen);
|
|
|
|
|
pos+= mblen;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
switch (*pos) {
|
|
|
|
|
case 0: /* Must be escaped for 'mysql' */
|
|
|
|
|
res->append('\\');
|
|
|
|
|
res->append('0');
|
|
|
|
|
break;
|
|
|
|
|
case '\n': /* Must be escaped for logs */
|
|
|
|
|
res->append('\\');
|
|
|
|
|
res->append('n');
|
|
|
|
|
break;
|
|
|
|
|
case '\r':
|
2004-10-07 00:45:06 +02:00
|
|
|
res->append('\\'); /* This gives better readability */
|
2000-07-31 21:29:14 +02:00
|
|
|
res->append('r');
|
|
|
|
|
break;
|
|
|
|
|
case '\\':
|
|
|
|
|
res->append('\\'); /* Because of the sql syntax */
|
|
|
|
|
res->append('\\');
|
|
|
|
|
break;
|
|
|
|
|
case '\'':
|
|
|
|
|
res->append('\''); /* Because of the sql syntax */
|
|
|
|
|
res->append('\'');
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
res->append(*pos);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2002-06-02 20:22:20 +02:00
|
|
|
res->append('\'');
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
|
2005-12-31 06:01:26 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
/* Create a .frm file */
|
|
|
|
|
|
2005-11-23 21:45:02 +01:00
|
|
|
File create_frm(THD *thd, const char *name, const char *db,
|
2005-07-28 16:09:54 +02:00
|
|
|
const char *table, uint reclength, uchar *fileinfo,
|
2005-11-23 21:45:02 +01:00
|
|
|
HA_CREATE_INFO *create_info, uint keys)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
register File file;
|
|
|
|
|
ulong length;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
uchar fill[IO_SIZE];
|
2005-03-03 19:51:29 +01:00
|
|
|
int create_flags= O_RDWR | O_TRUNC;
|
|
|
|
|
|
|
|
|
|
if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
|
|
|
|
|
create_flags|= O_EXCL | O_NOFOLLOW;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2004-06-21 09:21:20 +02:00
|
|
|
/* Fix this when we have new .frm files; Current limit is 4G rows (QQ) */
|
2005-11-24 02:05:59 +01:00
|
|
|
if (create_info->max_rows > UINT_MAX32)
|
|
|
|
|
create_info->max_rows= UINT_MAX32;
|
|
|
|
|
if (create_info->min_rows > UINT_MAX32)
|
|
|
|
|
create_info->min_rows= UINT_MAX32;
|
2005-12-09 16:55:59 +01:00
|
|
|
|
2005-07-22 05:08:54 +02:00
|
|
|
if ((file= my_create(name, CREATE_MODE, create_flags, MYF(0))) >= 0)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2005-05-25 17:33:36 +02:00
|
|
|
uint key_length, tmp_key_length;
|
|
|
|
|
uint tmp;
|
2000-07-31 21:29:14 +02:00
|
|
|
bzero((char*) fileinfo,64);
|
2004-12-06 01:00:37 +01:00
|
|
|
/* header */
|
|
|
|
|
fileinfo[0]=(uchar) 254;
|
|
|
|
|
fileinfo[1]= 1;
|
|
|
|
|
fileinfo[2]= FRM_VER+3+ test(create_info->varchar);
|
|
|
|
|
|
2005-12-21 19:18:40 +01:00
|
|
|
fileinfo[3]= (uchar) ha_legacy_type(
|
|
|
|
|
ha_checktype(thd,ha_legacy_type(create_info->db_type),0,0));
|
2000-07-31 21:29:14 +02:00
|
|
|
fileinfo[4]=1;
|
|
|
|
|
int2store(fileinfo+6,IO_SIZE); /* Next block starts here */
|
2007-06-27 13:35:49 +02:00
|
|
|
/*
|
|
|
|
|
Keep in sync with pack_keys() in unireg.cc
|
|
|
|
|
For each key:
|
|
|
|
|
8 bytes for the key header
|
|
|
|
|
9 bytes for each key-part (MAX_REF_PARTS)
|
|
|
|
|
NAME_LEN bytes for the name
|
|
|
|
|
1 byte for the NAMES_SEP_CHAR (before the name)
|
|
|
|
|
For all keys:
|
|
|
|
|
6 bytes for the header
|
|
|
|
|
1 byte for the NAMES_SEP_CHAR (after the last name)
|
|
|
|
|
9 extra bytes (padding for safety? alignment?)
|
|
|
|
|
*/
|
|
|
|
|
key_length= keys * (8 + MAX_REF_PARTS * 9 + NAME_LEN + 1) + 16;
|
2005-10-10 20:01:45 +02:00
|
|
|
length= next_io_size((ulong) (IO_SIZE+key_length+reclength+
|
|
|
|
|
create_info->extra_size));
|
2000-07-31 21:29:14 +02:00
|
|
|
int4store(fileinfo+10,length);
|
2005-05-25 17:33:36 +02:00
|
|
|
tmp_key_length= (key_length < 0xffff) ? key_length : 0xffff;
|
|
|
|
|
int2store(fileinfo+14,tmp_key_length);
|
2000-07-31 21:29:14 +02:00
|
|
|
int2store(fileinfo+16,reclength);
|
|
|
|
|
int4store(fileinfo+18,create_info->max_rows);
|
|
|
|
|
int4store(fileinfo+22,create_info->min_rows);
|
2007-10-11 17:07:40 +02:00
|
|
|
/* fileinfo[26] is set in mysql_create_frm() */
|
2000-07-31 21:29:14 +02:00
|
|
|
fileinfo[27]=2; // Use long pack-fields
|
2007-10-11 17:07:40 +02:00
|
|
|
/* fileinfo[28 & 29] is set to key_info_length in mysql_create_frm() */
|
2000-07-31 21:29:14 +02:00
|
|
|
create_info->table_options|=HA_OPTION_LONG_BLOB_PTR; // Use portable blob pointers
|
|
|
|
|
int2store(fileinfo+30,create_info->table_options);
|
|
|
|
|
fileinfo[32]=0; // No filename anymore
|
2005-03-22 14:48:06 +01:00
|
|
|
fileinfo[33]=5; // Mark for 5.0 frm file
|
2000-07-31 21:29:14 +02:00
|
|
|
int4store(fileinfo+34,create_info->avg_row_length);
|
2003-11-18 12:47:27 +01:00
|
|
|
fileinfo[38]= (create_info->default_table_charset ?
|
|
|
|
|
create_info->default_table_charset->number : 0);
|
2007-10-11 17:07:40 +02:00
|
|
|
fileinfo[39]= (uchar) ((uint) create_info->transactional |
|
|
|
|
|
((uint) create_info->page_checksum << 2));
|
2000-07-31 21:29:14 +02:00
|
|
|
fileinfo[40]= (uchar) create_info->row_type;
|
2007-10-11 17:07:40 +02:00
|
|
|
/* Next few bytes where for RAID support */
|
2006-02-12 02:21:01 +01:00
|
|
|
fileinfo[41]= 0;
|
|
|
|
|
fileinfo[42]= 0;
|
|
|
|
|
fileinfo[43]= 0;
|
|
|
|
|
fileinfo[44]= 0;
|
|
|
|
|
fileinfo[45]= 0;
|
|
|
|
|
fileinfo[46]= 0;
|
2005-05-25 17:33:36 +02:00
|
|
|
int4store(fileinfo+47, key_length);
|
|
|
|
|
tmp= MYSQL_VERSION_ID; // Store to avoid warning from int4store
|
|
|
|
|
int4store(fileinfo+51, tmp);
|
2006-01-17 08:40:00 +01:00
|
|
|
int4store(fileinfo+55, create_info->extra_size);
|
2006-05-03 14:59:17 +02:00
|
|
|
/*
|
|
|
|
|
59-60 is reserved for extra_rec_buf_length,
|
|
|
|
|
61 for default_part_db_type
|
|
|
|
|
*/
|
|
|
|
|
int2store(fileinfo+62, create_info->key_block_size);
|
2000-07-31 21:29:14 +02:00
|
|
|
bzero(fill,IO_SIZE);
|
|
|
|
|
for (; length > IO_SIZE ; length-= IO_SIZE)
|
|
|
|
|
{
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (my_write(file,fill, IO_SIZE, MYF(MY_WME | MY_NABP)))
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
|
|
|
|
VOID(my_close(file,MYF(0)));
|
|
|
|
|
VOID(my_delete(name,MYF(0)));
|
|
|
|
|
return(-1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-07-22 05:08:54 +02:00
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (my_errno == ENOENT)
|
|
|
|
|
my_error(ER_BAD_DB_ERROR,MYF(0),db);
|
|
|
|
|
else
|
|
|
|
|
my_error(ER_CANT_CREATE_TABLE,MYF(0),table,my_errno);
|
|
|
|
|
}
|
2000-07-31 21:29:14 +02:00
|
|
|
return (file);
|
|
|
|
|
} /* create_frm */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void update_create_info_from_table(HA_CREATE_INFO *create_info, TABLE *table)
|
|
|
|
|
{
|
2005-01-06 12:00:13 +01:00
|
|
|
TABLE_SHARE *share= table->s;
|
2001-09-30 04:47:35 +02:00
|
|
|
DBUG_ENTER("update_create_info_from_table");
|
2005-01-06 12:00:13 +01:00
|
|
|
|
|
|
|
|
create_info->max_rows= share->max_rows;
|
|
|
|
|
create_info->min_rows= share->min_rows;
|
|
|
|
|
create_info->table_options= share->db_create_options;
|
|
|
|
|
create_info->avg_row_length= share->avg_row_length;
|
|
|
|
|
create_info->row_type= share->row_type;
|
|
|
|
|
create_info->default_table_charset= share->table_charset;
|
2003-11-18 12:47:27 +01:00
|
|
|
create_info->table_charset= 0;
|
2007-08-08 12:02:07 +02:00
|
|
|
create_info->comment= share->comment;
|
2005-01-06 12:00:13 +01:00
|
|
|
|
2001-09-30 04:47:35 +02:00
|
|
|
DBUG_VOID_RETURN;
|
2001-12-06 13:10:51 +01:00
|
|
|
}
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
int
|
|
|
|
|
rename_file_ext(const char * from,const char * to,const char * ext)
|
|
|
|
|
{
|
|
|
|
|
char from_b[FN_REFLEN],to_b[FN_REFLEN];
|
|
|
|
|
VOID(strxmov(from_b,from,ext,NullS));
|
|
|
|
|
VOID(strxmov(to_b,to,ext,NullS));
|
|
|
|
|
return (my_rename(from_b,to_b,MYF(MY_WME)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-05-29 23:47:31 +02:00
|
|
|
/*
|
|
|
|
|
Allocate string field in MEM_ROOT and return it as String
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
get_field()
|
|
|
|
|
mem MEM_ROOT for allocating
|
|
|
|
|
field Field for retrieving of string
|
|
|
|
|
res result String
|
|
|
|
|
|
|
|
|
|
RETURN VALUES
|
2003-08-19 15:00:12 +02:00
|
|
|
1 string is empty
|
|
|
|
|
0 all ok
|
2003-05-29 23:47:31 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
bool get_field(MEM_ROOT *mem, Field *field, String *res)
|
|
|
|
|
{
|
2003-08-19 15:00:12 +02:00
|
|
|
char buff[MAX_FIELD_WIDTH], *to;
|
2003-05-29 23:47:31 +02:00
|
|
|
String str(buff,sizeof(buff),&my_charset_bin);
|
2003-08-19 15:00:12 +02:00
|
|
|
uint length;
|
|
|
|
|
|
2004-04-06 21:35:26 +02:00
|
|
|
field->val_str(&str);
|
2003-08-19 15:00:12 +02:00
|
|
|
if (!(length= str.length()))
|
2005-03-15 15:07:28 +01:00
|
|
|
{
|
|
|
|
|
res->length(0);
|
2003-08-19 15:00:12 +02:00
|
|
|
return 1;
|
2005-03-15 15:07:28 +01:00
|
|
|
}
|
|
|
|
|
if (!(to= strmake_root(mem, str.ptr(), length)))
|
|
|
|
|
length= 0; // Safety fix
|
2003-08-19 15:00:12 +02:00
|
|
|
res->set(to, length, ((Field_str*)field)->charset());
|
|
|
|
|
return 0;
|
2003-05-29 23:47:31 +02:00
|
|
|
}
|
|
|
|
|
|
2003-08-19 15:00:12 +02:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
/*
|
2003-02-12 20:55:37 +01:00
|
|
|
Allocate string field in MEM_ROOT and return it as NULL-terminated string
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
get_field()
|
|
|
|
|
mem MEM_ROOT for allocating
|
|
|
|
|
field Field for retrieving of string
|
|
|
|
|
|
|
|
|
|
RETURN VALUES
|
|
|
|
|
NullS string is empty
|
|
|
|
|
# pointer to NULL-terminated string value of field
|
2000-07-31 21:29:14 +02:00
|
|
|
*/
|
|
|
|
|
|
2003-02-12 20:55:37 +01:00
|
|
|
char *get_field(MEM_ROOT *mem, Field *field)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2003-12-19 15:25:50 +01:00
|
|
|
char buff[MAX_FIELD_WIDTH], *to;
|
2003-03-07 10:39:53 +01:00
|
|
|
String str(buff,sizeof(buff),&my_charset_bin);
|
2003-08-19 15:00:12 +02:00
|
|
|
uint length;
|
|
|
|
|
|
2004-04-06 21:35:26 +02:00
|
|
|
field->val_str(&str);
|
2003-12-19 15:25:50 +01:00
|
|
|
length= str.length();
|
2003-12-09 20:49:48 +01:00
|
|
|
if (!length || !(to= (char*) alloc_root(mem,length+1)))
|
2000-07-31 21:29:14 +02:00
|
|
|
return NullS;
|
|
|
|
|
memcpy(to,str.ptr(),(uint) length);
|
|
|
|
|
to[length]=0;
|
|
|
|
|
return to;
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-29 10:40:26 +01:00
|
|
|
/*
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
given a buffer with a key value, and a map of keyparts
|
|
|
|
|
that are present in this value, returns the length of the value
|
|
|
|
|
*/
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
uint calculate_key_len(TABLE *table, uint key, const uchar *buf,
|
2007-03-17 00:13:25 +01:00
|
|
|
key_part_map keypart_map)
|
2007-01-29 10:40:26 +01:00
|
|
|
{
|
|
|
|
|
/* works only with key prefixes */
|
|
|
|
|
DBUG_ASSERT(((keypart_map + 1) & keypart_map) == 0);
|
|
|
|
|
|
|
|
|
|
KEY *key_info= table->s->key_info+key;
|
|
|
|
|
KEY_PART_INFO *key_part= key_info->key_part;
|
|
|
|
|
KEY_PART_INFO *end_key_part= key_part + key_info->key_parts;
|
|
|
|
|
uint length= 0;
|
|
|
|
|
|
|
|
|
|
while (key_part < end_key_part && keypart_map)
|
|
|
|
|
{
|
|
|
|
|
length+= key_part->store_length;
|
|
|
|
|
keypart_map >>= 1;
|
|
|
|
|
key_part++;
|
|
|
|
|
}
|
|
|
|
|
return length;
|
|
|
|
|
}
|
2003-01-29 17:56:34 +01:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Check if database name is valid
|
|
|
|
|
|
|
|
|
|
SYNPOSIS
|
|
|
|
|
check_db_name()
|
2006-10-16 18:57:33 +02:00
|
|
|
org_name Name of database and length
|
2003-01-29 17:56:34 +01:00
|
|
|
|
|
|
|
|
NOTES
|
|
|
|
|
If lower_case_table_names is set then database is converted to lower case
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
0 ok
|
|
|
|
|
1 error
|
|
|
|
|
*/
|
|
|
|
|
|
2006-10-16 18:57:33 +02:00
|
|
|
bool check_db_name(LEX_STRING *org_name)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2006-10-16 18:57:33 +02:00
|
|
|
char *name= org_name->str;
|
2007-04-03 13:13:27 +02:00
|
|
|
uint name_length= org_name->length;
|
2006-10-16 18:57:33 +02:00
|
|
|
|
2007-04-03 13:13:27 +02:00
|
|
|
if (!name_length || name_length > NAME_LEN)
|
2006-10-16 18:57:33 +02:00
|
|
|
return 1;
|
2003-01-29 17:56:34 +01:00
|
|
|
|
2004-04-06 12:31:25 +02:00
|
|
|
if (lower_case_table_names && name != any_db)
|
2003-02-07 14:47:24 +01:00
|
|
|
my_casedn_str(files_charset_info, name);
|
2003-01-29 17:56:34 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
2006-10-16 18:57:33 +02:00
|
|
|
if (use_mb(system_charset_info))
|
|
|
|
|
{
|
2007-04-03 13:13:27 +02:00
|
|
|
name_length= 0;
|
2006-10-16 18:57:33 +02:00
|
|
|
bool last_char_is_space= TRUE;
|
|
|
|
|
char *end= name + org_name->length;
|
|
|
|
|
while (name < end)
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2006-10-16 18:57:33 +02:00
|
|
|
int len;
|
|
|
|
|
last_char_is_space= my_isspace(system_charset_info, *name);
|
|
|
|
|
len= my_ismbchar(system_charset_info, name, end);
|
|
|
|
|
if (!len)
|
|
|
|
|
len= 1;
|
|
|
|
|
name+= len;
|
2007-04-03 13:13:27 +02:00
|
|
|
name_length++;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2007-04-03 13:13:27 +02:00
|
|
|
return (last_char_is_space || name_length > NAME_CHAR_LEN);
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2006-10-16 18:57:33 +02:00
|
|
|
else
|
|
|
|
|
#endif
|
2007-04-03 13:13:27 +02:00
|
|
|
return ((org_name->str[org_name->length - 1] != ' ') ||
|
|
|
|
|
(name_length > NAME_CHAR_LEN)); /* purecov: inspected */
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Allow anything as a table name, as long as it doesn't contain an
|
2005-12-31 06:01:26 +01:00
|
|
|
' ' at the end
|
2000-07-31 21:29:14 +02:00
|
|
|
returns 1 on error
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool check_table_name(const char *name, uint length)
|
|
|
|
|
{
|
2007-04-03 13:13:27 +02:00
|
|
|
uint name_length= 0; // name length in symbols
|
2000-07-31 21:29:14 +02:00
|
|
|
const char *end= name+length;
|
2003-03-14 16:08:42 +01:00
|
|
|
if (!length || length > NAME_LEN)
|
|
|
|
|
return 1;
|
2004-03-05 19:13:33 +01:00
|
|
|
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
2004-03-12 14:55:33 +01:00
|
|
|
bool last_char_is_space= FALSE;
|
2004-03-05 19:13:33 +01:00
|
|
|
#else
|
|
|
|
|
if (name[length-1]==' ')
|
|
|
|
|
return 1;
|
|
|
|
|
#endif
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
|
while (name != end)
|
|
|
|
|
{
|
|
|
|
|
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
2006-03-20 11:43:02 +01:00
|
|
|
last_char_is_space= my_isspace(system_charset_info, *name);
|
2002-03-12 18:37:58 +01:00
|
|
|
if (use_mb(system_charset_info))
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2002-03-12 18:37:58 +01:00
|
|
|
int len=my_ismbchar(system_charset_info, name, end);
|
2000-07-31 21:29:14 +02:00
|
|
|
if (len)
|
|
|
|
|
{
|
|
|
|
|
name += len;
|
2007-04-03 13:13:27 +02:00
|
|
|
name_length++;
|
2000-07-31 21:29:14 +02:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
name++;
|
2007-04-03 13:13:27 +02:00
|
|
|
name_length++;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2004-03-05 19:13:33 +01:00
|
|
|
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
2007-04-03 13:13:27 +02:00
|
|
|
return (last_char_is_space || name_length > NAME_CHAR_LEN) ;
|
2004-03-12 14:55:33 +01:00
|
|
|
#else
|
2000-07-31 21:29:14 +02:00
|
|
|
return 0;
|
2004-03-12 14:55:33 +01:00
|
|
|
#endif
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
|
2004-03-12 14:56:28 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
bool check_column_name(const char *name)
|
|
|
|
|
{
|
2007-04-03 13:13:27 +02:00
|
|
|
uint name_length= 0; // name length in symbols
|
2004-03-16 21:41:30 +01:00
|
|
|
bool last_char_is_space= TRUE;
|
2004-03-12 14:55:33 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
while (*name)
|
|
|
|
|
{
|
|
|
|
|
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
2006-03-20 11:43:02 +01:00
|
|
|
last_char_is_space= my_isspace(system_charset_info, *name);
|
2002-03-12 18:37:58 +01:00
|
|
|
if (use_mb(system_charset_info))
|
2000-07-31 21:29:14 +02:00
|
|
|
{
|
2002-03-12 18:37:58 +01:00
|
|
|
int len=my_ismbchar(system_charset_info, name,
|
2004-12-06 01:00:37 +01:00
|
|
|
name+system_charset_info->mbmaxlen);
|
2000-07-31 21:29:14 +02:00
|
|
|
if (len)
|
|
|
|
|
{
|
|
|
|
|
name += len;
|
2007-04-03 13:13:27 +02:00
|
|
|
name_length++;
|
2000-07-31 21:29:14 +02:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
2004-03-05 19:13:33 +01:00
|
|
|
#else
|
2004-03-12 14:55:33 +01:00
|
|
|
last_char_is_space= *name==' ';
|
2000-07-31 21:29:14 +02:00
|
|
|
#endif
|
|
|
|
|
if (*name == NAMES_SEP_CHAR)
|
|
|
|
|
return 1;
|
|
|
|
|
name++;
|
2007-04-03 13:13:27 +02:00
|
|
|
name_length++;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
2003-03-14 16:08:42 +01:00
|
|
|
/* Error if empty or too long column name */
|
2007-04-03 13:13:27 +02:00
|
|
|
return last_char_is_space || (uint) name_length > NAME_CHAR_LEN;
|
2000-07-31 21:29:14 +02:00
|
|
|
}
|
|
|
|
|
|
2006-02-14 16:20:48 +01:00
|
|
|
|
2007-04-05 13:24:34 +02:00
|
|
|
/**
|
2006-02-14 16:20:48 +01:00
|
|
|
Checks whether a table is intact. Should be done *just* after the table has
|
|
|
|
|
been opened.
|
2007-04-05 13:24:34 +02:00
|
|
|
|
|
|
|
|
@param[in] table The table to check
|
|
|
|
|
@param[in] table_f_count Expected number of columns in the table
|
|
|
|
|
@param[in] table_def Expected structure of the table (column name
|
|
|
|
|
and type)
|
|
|
|
|
|
|
|
|
|
@retval FALSE OK
|
|
|
|
|
@retval TRUE There was an error. An error message is output
|
|
|
|
|
to the error log. We do not push an error
|
|
|
|
|
message into the error stack because this
|
|
|
|
|
function is currently only called at start up,
|
|
|
|
|
and such errors never reach the user.
|
2006-02-14 16:20:48 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
my_bool
|
2006-08-17 14:22:59 +02:00
|
|
|
table_check_intact(TABLE *table, const uint table_f_count,
|
2007-04-05 13:24:34 +02:00
|
|
|
const TABLE_FIELD_W_TYPE *table_def)
|
2006-02-14 16:20:48 +01:00
|
|
|
{
|
|
|
|
|
uint i;
|
|
|
|
|
my_bool error= FALSE;
|
|
|
|
|
my_bool fields_diff_count;
|
|
|
|
|
DBUG_ENTER("table_check_intact");
|
2007-04-05 13:24:34 +02:00
|
|
|
DBUG_PRINT("info",("table: %s expected_count: %d",
|
|
|
|
|
table->alias, table_f_count));
|
|
|
|
|
|
|
|
|
|
fields_diff_count= (table->s->fields != table_f_count);
|
|
|
|
|
if (fields_diff_count)
|
2006-02-14 16:20:48 +01:00
|
|
|
{
|
2007-04-05 13:24:34 +02:00
|
|
|
DBUG_PRINT("info", ("Column count has changed, checking the definition"));
|
|
|
|
|
|
|
|
|
|
/* previous MySQL version */
|
|
|
|
|
if (MYSQL_VERSION_ID > table->s->mysql_version)
|
2006-02-14 16:20:48 +01:00
|
|
|
{
|
2007-04-05 13:24:34 +02:00
|
|
|
sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE),
|
|
|
|
|
table->alias, table_f_count, table->s->fields,
|
|
|
|
|
table->s->mysql_version, MYSQL_VERSION_ID);
|
|
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
|
}
|
|
|
|
|
else if (MYSQL_VERSION_ID == table->s->mysql_version)
|
|
|
|
|
{
|
|
|
|
|
sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_CORRUPTED), table->alias,
|
|
|
|
|
table_f_count, table->s->fields);
|
|
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
Something has definitely changed, but we're running an older
|
|
|
|
|
version of MySQL with new system tables.
|
|
|
|
|
Let's check column definitions. If a column was added at
|
|
|
|
|
the end of the table, then we don't care much since such change
|
|
|
|
|
is backward compatible.
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
char buffer[STRING_BUFFER_USUAL_SIZE];
|
|
|
|
|
for (i=0 ; i < table_f_count; i++, table_def++)
|
|
|
|
|
{
|
|
|
|
|
String sql_type(buffer, sizeof(buffer), system_charset_info);
|
|
|
|
|
sql_type.length(0);
|
|
|
|
|
if (i < table->s->fields)
|
|
|
|
|
{
|
|
|
|
|
Field *field= table->field[i];
|
2006-05-30 18:18:13 +02:00
|
|
|
|
2007-04-05 13:24:34 +02:00
|
|
|
if (strncmp(field->field_name, table_def->name.str,
|
|
|
|
|
table_def->name.length))
|
2006-06-06 01:47:30 +02:00
|
|
|
{
|
2006-02-14 16:20:48 +01:00
|
|
|
/*
|
2007-04-05 13:24:34 +02:00
|
|
|
Name changes are not fatal, we use ordinal numbers to access columns.
|
|
|
|
|
Still this can be a sign of a tampered table, output an error
|
|
|
|
|
to the error log.
|
2006-02-14 16:20:48 +01:00
|
|
|
*/
|
2007-04-05 13:24:34 +02:00
|
|
|
sql_print_error("Incorrect definition of table %s.%s: "
|
|
|
|
|
"expected column '%s' at position %d, found '%s'.",
|
|
|
|
|
table->s->db.str, table->alias, table_def->name.str, i,
|
|
|
|
|
field->field_name);
|
2006-06-06 01:47:30 +02:00
|
|
|
}
|
2007-04-05 13:24:34 +02:00
|
|
|
field->sql_type(sql_type);
|
2006-02-14 16:20:48 +01:00
|
|
|
/*
|
2007-04-05 13:24:34 +02:00
|
|
|
Generally, if column types don't match, then something is
|
|
|
|
|
wrong.
|
|
|
|
|
|
|
|
|
|
However, we only compare column definitions up to the
|
|
|
|
|
length of the original definition, since we consider the
|
|
|
|
|
following definitions compatible:
|
|
|
|
|
|
|
|
|
|
1. DATETIME and DATETIM
|
|
|
|
|
2. INT(11) and INT(11
|
|
|
|
|
3. SET('one', 'two') and SET('one', 'two', 'more')
|
|
|
|
|
|
|
|
|
|
For SETs or ENUMs, if the same prefix is there it's OK to
|
|
|
|
|
add more elements - they will get higher ordinal numbers and
|
|
|
|
|
the new table definition is backward compatible with the
|
|
|
|
|
original one.
|
|
|
|
|
*/
|
|
|
|
|
if (strncmp(sql_type.c_ptr_safe(), table_def->type.str,
|
|
|
|
|
table_def->type.length - 1))
|
2006-02-14 16:20:48 +01:00
|
|
|
{
|
2007-04-05 13:24:34 +02:00
|
|
|
sql_print_error("Incorrect definition of table %s.%s: "
|
|
|
|
|
"expected column '%s' at position %d to have type "
|
|
|
|
|
"%s, found type %s.", table->s->db.str, table->alias,
|
|
|
|
|
table_def->name.str, i, table_def->type.str,
|
|
|
|
|
sql_type.c_ptr_safe());
|
|
|
|
|
error= TRUE;
|
2006-02-14 16:20:48 +01:00
|
|
|
}
|
2007-04-05 13:24:34 +02:00
|
|
|
else if (table_def->cset.str && !field->has_charset())
|
|
|
|
|
{
|
|
|
|
|
sql_print_error("Incorrect definition of table %s.%s: "
|
|
|
|
|
"expected the type of column '%s' at position %d "
|
|
|
|
|
"to have character set '%s' but the type has no "
|
|
|
|
|
"character set.", table->s->db.str, table->alias,
|
|
|
|
|
table_def->name.str, i, table_def->cset.str);
|
|
|
|
|
error= TRUE;
|
|
|
|
|
}
|
|
|
|
|
else if (table_def->cset.str &&
|
|
|
|
|
strcmp(field->charset()->csname, table_def->cset.str))
|
2006-02-14 16:20:48 +01:00
|
|
|
{
|
2007-04-05 13:24:34 +02:00
|
|
|
sql_print_error("Incorrect definition of table %s.%s: "
|
|
|
|
|
"expected the type of column '%s' at position %d "
|
|
|
|
|
"to have character set '%s' but found "
|
|
|
|
|
"character set '%s'.", table->s->db.str, table->alias,
|
|
|
|
|
table_def->name.str, i, table_def->cset.str,
|
|
|
|
|
field->charset()->csname);
|
|
|
|
|
error= TRUE;
|
2006-02-14 16:20:48 +01:00
|
|
|
}
|
|
|
|
|
}
|
2007-04-05 13:24:34 +02:00
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
sql_print_error("Incorrect definition of table %s.%s: "
|
|
|
|
|
"expected column '%s' at position %d to have type %s "
|
|
|
|
|
" but the column is not found.",
|
|
|
|
|
table->s->db.str, table->alias,
|
|
|
|
|
table_def->name.str, i, table_def->type.str);
|
|
|
|
|
error= TRUE;
|
|
|
|
|
}
|
2006-02-14 16:20:48 +01:00
|
|
|
}
|
2007-04-05 13:24:34 +02:00
|
|
|
DBUG_RETURN(error);
|
2006-02-14 16:20:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-09-22 00:11:21 +02:00
|
|
|
/*
|
|
|
|
|
Create Item_field for each column in the table.
|
|
|
|
|
|
|
|
|
|
SYNPOSIS
|
|
|
|
|
st_table::fill_item_list()
|
|
|
|
|
item_list a pointer to an empty list used to store items
|
|
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Create Item_field object for each column in the table and
|
|
|
|
|
initialize it with the corresponding Field. New items are
|
|
|
|
|
created in the current THD memory root.
|
|
|
|
|
|
|
|
|
|
RETURN VALUE
|
|
|
|
|
0 success
|
|
|
|
|
1 out of memory
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
bool st_table::fill_item_list(List<Item> *item_list) const
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
All Item_field's created using a direct pointer to a field
|
|
|
|
|
are fixed in Item_field constructor.
|
|
|
|
|
*/
|
|
|
|
|
for (Field **ptr= field; *ptr; ptr++)
|
|
|
|
|
{
|
|
|
|
|
Item_field *item= new Item_field(*ptr);
|
|
|
|
|
if (!item || item_list->push_back(item))
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Reset an existing list of Item_field items to point to the
|
|
|
|
|
Fields of this table.
|
|
|
|
|
|
|
|
|
|
SYNPOSIS
|
|
|
|
|
st_table::fill_item_list()
|
|
|
|
|
item_list a non-empty list with Item_fields
|
|
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
This is a counterpart of fill_item_list used to redirect
|
|
|
|
|
Item_fields to the fields of a newly created table.
|
|
|
|
|
The caller must ensure that number of items in the item_list
|
|
|
|
|
is the same as the number of columns in the table.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void st_table::reset_item_list(List<Item> *item_list) const
|
|
|
|
|
{
|
|
|
|
|
List_iterator_fast<Item> it(*item_list);
|
|
|
|
|
for (Field **ptr= field; *ptr; ptr++)
|
|
|
|
|
{
|
|
|
|
|
Item_field *item_field= (Item_field*) it++;
|
|
|
|
|
DBUG_ASSERT(item_field != 0);
|
|
|
|
|
item_field->reset_field(*ptr);
|
|
|
|
|
}
|
|
|
|
|
}
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2004-07-16 00:15:55 +02:00
|
|
|
/*
|
|
|
|
|
calculate md5 of query
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::calc_md5()
|
2004-07-16 00:15:55 +02:00
|
|
|
buffer buffer for md5 writing
|
|
|
|
|
*/
|
2004-09-03 20:43:04 +02:00
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
void TABLE_LIST::calc_md5(char *buffer)
|
2004-07-16 00:15:55 +02:00
|
|
|
{
|
|
|
|
|
my_MD5_CTX context;
|
2004-09-03 20:43:04 +02:00
|
|
|
uchar digest[16];
|
|
|
|
|
my_MD5Init(&context);
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
my_MD5Update(&context,(uchar *) select_stmt.str, select_stmt.length);
|
2004-09-03 20:43:04 +02:00
|
|
|
my_MD5Final(digest, &context);
|
2004-07-16 00:15:55 +02:00
|
|
|
sprintf((char *) buffer,
|
|
|
|
|
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
|
|
|
|
digest[0], digest[1], digest[2], digest[3],
|
|
|
|
|
digest[4], digest[5], digest[6], digest[7],
|
|
|
|
|
digest[8], digest[9], digest[10], digest[11],
|
|
|
|
|
digest[12], digest[13], digest[14], digest[15]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-09-03 16:45:40 +02:00
|
|
|
/**
|
|
|
|
|
@brief Set underlying table for table place holder of view.
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2008-09-03 16:45:40 +02:00
|
|
|
@details
|
2005-02-23 17:51:10 +01:00
|
|
|
|
2008-09-03 16:45:40 +02:00
|
|
|
Replace all views that only use one table with the table itself. This
|
|
|
|
|
allows us to treat the view as a simple table and even update it (it is a
|
|
|
|
|
kind of optimization).
|
|
|
|
|
|
|
|
|
|
@note
|
|
|
|
|
|
|
|
|
|
This optimization is potentially dangerous as it makes views
|
|
|
|
|
masquerade as base tables: Views don't have the pointer TABLE_LIST::table
|
|
|
|
|
set to non-@c NULL.
|
|
|
|
|
|
|
|
|
|
We may have the case where a view accesses tables not normally accessible
|
|
|
|
|
in the current Security_context (only in the definer's
|
|
|
|
|
Security_context). According to the table's GRANT_INFO (TABLE::grant),
|
|
|
|
|
access is fulfilled, but this is implicitly meant in the definer's security
|
|
|
|
|
context. Hence we must never look at only a TABLE's GRANT_INFO without
|
|
|
|
|
looking at the one of the referring TABLE_LIST.
|
2004-07-16 00:15:55 +02:00
|
|
|
*/
|
2004-09-03 20:43:04 +02:00
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
void TABLE_LIST::set_underlying_merge()
|
2004-07-16 00:15:55 +02:00
|
|
|
{
|
2005-02-23 17:51:10 +01:00
|
|
|
TABLE_LIST *tbl;
|
|
|
|
|
|
2005-10-27 23:18:23 +02:00
|
|
|
if ((tbl= merge_underlying_list))
|
2004-11-21 19:08:12 +01:00
|
|
|
{
|
2005-02-23 17:51:10 +01:00
|
|
|
/* This is a view. Process all tables of view */
|
2005-10-27 23:18:23 +02:00
|
|
|
DBUG_ASSERT(view && effective_algorithm == VIEW_ALGORITHM_MERGE);
|
2005-02-23 17:51:10 +01:00
|
|
|
do
|
|
|
|
|
{
|
2005-10-27 23:18:23 +02:00
|
|
|
if (tbl->merge_underlying_list) // This is a view
|
2005-02-23 17:51:10 +01:00
|
|
|
{
|
2005-10-27 23:18:23 +02:00
|
|
|
DBUG_ASSERT(tbl->view &&
|
|
|
|
|
tbl->effective_algorithm == VIEW_ALGORITHM_MERGE);
|
2005-02-23 17:51:10 +01:00
|
|
|
/*
|
|
|
|
|
This is the only case where set_ancestor is called on an object
|
|
|
|
|
that may not be a view (in which case ancestor is 0)
|
|
|
|
|
*/
|
2005-10-27 23:18:23 +02:00
|
|
|
tbl->merge_underlying_list->set_underlying_merge();
|
2005-02-23 17:51:10 +01:00
|
|
|
}
|
|
|
|
|
} while ((tbl= tbl->next_local));
|
|
|
|
|
|
2005-05-11 01:31:13 +02:00
|
|
|
if (!multitable_view)
|
2005-02-23 17:51:10 +01:00
|
|
|
{
|
2005-10-27 23:18:23 +02:00
|
|
|
table= merge_underlying_list->table;
|
|
|
|
|
schema_table= merge_underlying_list->schema_table;
|
2005-02-23 17:51:10 +01:00
|
|
|
}
|
2004-11-21 19:08:12 +01:00
|
|
|
}
|
2004-09-14 18:28:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-07-16 00:15:55 +02:00
|
|
|
/*
|
|
|
|
|
setup fields of placeholder of merged VIEW
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::setup_underlying()
|
2004-10-21 17:10:59 +02:00
|
|
|
thd - thread handler
|
2005-07-01 06:05:42 +02:00
|
|
|
|
2004-10-07 00:45:06 +02:00
|
|
|
DESCRIPTION
|
|
|
|
|
It is:
|
2005-07-01 06:05:42 +02:00
|
|
|
- preparing translation table for view columns
|
2004-10-07 00:45:06 +02:00
|
|
|
If there are underlying view(s) procedure first will be called for them.
|
|
|
|
|
|
2004-07-16 00:15:55 +02:00
|
|
|
RETURN
|
2005-02-23 17:51:10 +01:00
|
|
|
FALSE - OK
|
|
|
|
|
TRUE - error
|
2004-07-16 00:15:55 +02:00
|
|
|
*/
|
2004-09-03 20:43:04 +02:00
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
bool TABLE_LIST::setup_underlying(THD *thd)
|
2004-07-16 00:15:55 +02:00
|
|
|
{
|
2007-07-06 14:18:49 +02:00
|
|
|
DBUG_ENTER("TABLE_LIST::setup_underlying");
|
2005-10-27 23:18:23 +02:00
|
|
|
|
|
|
|
|
if (!field_translation && merge_underlying_list)
|
2004-09-14 18:28:29 +02:00
|
|
|
{
|
2005-07-01 06:05:42 +02:00
|
|
|
Field_translator *transl;
|
|
|
|
|
SELECT_LEX *select= &view->select_lex;
|
|
|
|
|
Item *item;
|
|
|
|
|
TABLE_LIST *tbl;
|
|
|
|
|
List_iterator_fast<Item> it(select->item_list);
|
|
|
|
|
uint field_count= 0;
|
|
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
if (check_stack_overrun(thd, STACK_MIN_SIZE, (uchar*) &field_count))
|
2005-07-01 06:05:42 +02:00
|
|
|
{
|
2005-02-23 17:51:10 +01:00
|
|
|
DBUG_RETURN(TRUE);
|
2005-07-01 06:05:42 +02:00
|
|
|
}
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2005-10-27 23:18:23 +02:00
|
|
|
for (tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
|
2005-07-01 06:05:42 +02:00
|
|
|
{
|
2005-10-27 23:18:23 +02:00
|
|
|
if (tbl->merge_underlying_list &&
|
|
|
|
|
tbl->setup_underlying(thd))
|
2005-07-01 06:05:42 +02:00
|
|
|
{
|
|
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-02-23 17:51:10 +01:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
/* Create view fields translation table */
|
|
|
|
|
|
|
|
|
|
if (!(transl=
|
2005-09-02 15:21:19 +02:00
|
|
|
(Field_translator*)(thd->stmt_arena->
|
2005-07-01 06:05:42 +02:00
|
|
|
alloc(select->item_list.elements *
|
|
|
|
|
sizeof(Field_translator)))))
|
2004-07-16 00:15:55 +02:00
|
|
|
{
|
2005-07-01 06:05:42 +02:00
|
|
|
DBUG_RETURN(TRUE);
|
2004-09-14 18:28:29 +02:00
|
|
|
}
|
2005-07-01 06:05:42 +02:00
|
|
|
|
|
|
|
|
while ((item= it++))
|
2004-09-14 18:28:29 +02:00
|
|
|
{
|
2005-07-01 06:05:42 +02:00
|
|
|
transl[field_count].name= item->name;
|
|
|
|
|
transl[field_count++].item= item;
|
2004-09-14 18:28:29 +02:00
|
|
|
}
|
2005-07-01 06:05:42 +02:00
|
|
|
field_translation= transl;
|
|
|
|
|
field_translation_end= transl + field_count;
|
|
|
|
|
/* TODO: use hash for big number of fields */
|
2004-09-14 18:28:29 +02:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
/* full text function moving to current select */
|
|
|
|
|
if (view->select_lex.ftfunc_list->elements)
|
2004-09-14 18:28:29 +02:00
|
|
|
{
|
2005-07-01 06:05:42 +02:00
|
|
|
Item_func_match *ifm;
|
|
|
|
|
SELECT_LEX *current_select= thd->lex->current_select;
|
|
|
|
|
List_iterator_fast<Item_func_match>
|
|
|
|
|
li(*(view->select_lex.ftfunc_list));
|
|
|
|
|
while ((ifm= li++))
|
|
|
|
|
current_select->ftfunc_list->push_front(ifm);
|
2004-07-16 00:15:55 +02:00
|
|
|
}
|
|
|
|
|
}
|
2005-07-01 06:05:42 +02:00
|
|
|
DBUG_RETURN(FALSE);
|
|
|
|
|
}
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2005-02-23 17:51:10 +01:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
/*
|
|
|
|
|
Prepare where expression of view
|
2004-07-21 03:26:20 +02:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::prep_where()
|
2005-07-01 06:05:42 +02:00
|
|
|
thd - thread handler
|
|
|
|
|
conds - condition of this JOIN
|
|
|
|
|
no_where_clause - do not build WHERE or ON outer qwery do not need it
|
|
|
|
|
(it is INSERT), we do not need conds if this flag is set
|
2004-07-23 08:20:58 +02:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
NOTE: have to be called befor CHECK OPTION preparation, because it makes
|
|
|
|
|
fix_fields for view WHERE clause
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
RETURN
|
|
|
|
|
FALSE - OK
|
|
|
|
|
TRUE - error
|
|
|
|
|
*/
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
bool TABLE_LIST::prep_where(THD *thd, Item **conds,
|
2005-07-01 06:05:42 +02:00
|
|
|
bool no_where_clause)
|
|
|
|
|
{
|
2007-07-06 14:18:49 +02:00
|
|
|
DBUG_ENTER("TABLE_LIST::prep_where");
|
2005-07-01 06:05:42 +02:00
|
|
|
|
2005-10-27 23:18:23 +02:00
|
|
|
for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
|
2004-09-14 18:28:29 +02:00
|
|
|
{
|
2005-07-01 06:05:42 +02:00
|
|
|
if (tbl->view && tbl->prep_where(thd, conds, no_where_clause))
|
|
|
|
|
{
|
|
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
|
}
|
2004-09-14 18:28:29 +02:00
|
|
|
}
|
2004-09-10 21:39:04 +02:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
if (where)
|
|
|
|
|
{
|
|
|
|
|
if (!where->fixed && where->fix_fields(thd, &where))
|
2004-07-16 00:15:55 +02:00
|
|
|
{
|
2005-07-01 06:05:42 +02:00
|
|
|
DBUG_RETURN(TRUE);
|
2004-07-16 00:15:55 +02:00
|
|
|
}
|
2004-10-04 12:45:35 +02:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
check that it is not VIEW in which we insert with INSERT SELECT
|
|
|
|
|
(in this case we can't add view WHERE condition to main SELECT_LEX)
|
|
|
|
|
*/
|
2005-07-01 06:05:42 +02:00
|
|
|
if (!no_where_clause && !where_processed)
|
2004-07-16 00:15:55 +02:00
|
|
|
{
|
2005-07-01 06:05:42 +02:00
|
|
|
TABLE_LIST *tbl= this;
|
2005-09-02 15:21:19 +02:00
|
|
|
Query_arena *arena= thd->stmt_arena, backup;
|
|
|
|
|
arena= thd->activate_stmt_arena_if_needed(&backup); // For easier test
|
2005-07-01 06:05:42 +02:00
|
|
|
|
2004-10-04 12:45:35 +02:00
|
|
|
/* Go up to join tree and try to find left join */
|
|
|
|
|
for (; tbl; tbl= tbl->embedding)
|
2004-09-03 14:18:40 +02:00
|
|
|
{
|
2004-10-04 12:45:35 +02:00
|
|
|
if (tbl->outer_join)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
Store WHERE condition to ON expression for outer join, because
|
2004-10-07 00:45:06 +02:00
|
|
|
we can't use WHERE to correctly execute left joins on VIEWs and
|
2004-10-04 12:45:35 +02:00
|
|
|
this expression will not be moved to WHERE condition (i.e. will
|
|
|
|
|
be clean correctly for PS/SP)
|
|
|
|
|
*/
|
2006-09-29 09:16:07 +02:00
|
|
|
tbl->on_expr= and_conds(tbl->on_expr,
|
|
|
|
|
where->copy_andor_structure(thd));
|
2004-10-04 12:45:35 +02:00
|
|
|
break;
|
|
|
|
|
}
|
2004-09-03 14:18:40 +02:00
|
|
|
}
|
2004-10-04 12:45:35 +02:00
|
|
|
if (tbl == 0)
|
2006-09-29 09:16:07 +02:00
|
|
|
*conds= and_conds(*conds, where->copy_andor_structure(thd));
|
2005-07-01 06:05:42 +02:00
|
|
|
if (arena)
|
2005-09-02 15:21:19 +02:00
|
|
|
thd->restore_active_arena(arena, &backup);
|
2005-07-01 06:05:42 +02:00
|
|
|
where_processed= TRUE;
|
2004-07-16 00:15:55 +02:00
|
|
|
}
|
|
|
|
|
}
|
2004-09-14 18:28:29 +02:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
DBUG_RETURN(FALSE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2007-05-31 23:15:40 +02:00
|
|
|
/*
|
|
|
|
|
Merge ON expressions for a view
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
merge_on_conds()
|
|
|
|
|
thd thread handle
|
|
|
|
|
table table for the VIEW
|
|
|
|
|
is_cascaded TRUE <=> merge ON expressions from underlying views
|
|
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
This function returns the result of ANDing the ON expressions
|
|
|
|
|
of the given view and all underlying views. The ON expressions
|
|
|
|
|
of the underlying views are added only if is_cascaded is TRUE.
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
Pointer to the built expression if there is any.
|
|
|
|
|
Otherwise and in the case of a failure NULL is returned.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static Item *
|
|
|
|
|
merge_on_conds(THD *thd, TABLE_LIST *table, bool is_cascaded)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ENTER("merge_on_conds");
|
|
|
|
|
|
|
|
|
|
Item *cond= NULL;
|
|
|
|
|
DBUG_PRINT("info", ("alias: %s", table->alias));
|
|
|
|
|
if (table->on_expr)
|
|
|
|
|
cond= table->on_expr->copy_andor_structure(thd);
|
|
|
|
|
if (!table->nested_join)
|
|
|
|
|
DBUG_RETURN(cond);
|
|
|
|
|
List_iterator<TABLE_LIST> li(table->nested_join->join_list);
|
|
|
|
|
while (TABLE_LIST *tbl= li++)
|
|
|
|
|
{
|
|
|
|
|
if (tbl->view && !is_cascaded)
|
|
|
|
|
continue;
|
|
|
|
|
cond= and_conds(cond, merge_on_conds(thd, tbl, is_cascaded));
|
|
|
|
|
}
|
|
|
|
|
DBUG_RETURN(cond);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
/*
|
|
|
|
|
Prepare check option expression of table
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::prep_check_option()
|
2005-07-01 06:05:42 +02:00
|
|
|
thd - thread handler
|
|
|
|
|
check_opt_type - WITH CHECK OPTION type (VIEW_CHECK_NONE,
|
|
|
|
|
VIEW_CHECK_LOCAL, VIEW_CHECK_CASCADED)
|
|
|
|
|
we use this parameter instead of direct check of
|
|
|
|
|
effective_with_check to change type of underlying
|
|
|
|
|
views to VIEW_CHECK_CASCADED if outer view have
|
|
|
|
|
such option and prevent processing of underlying
|
|
|
|
|
view check options if outer view have just
|
|
|
|
|
VIEW_CHECK_LOCAL option.
|
|
|
|
|
|
|
|
|
|
NOTE
|
2007-05-31 23:15:40 +02:00
|
|
|
This method builds check option condition to use it later on
|
|
|
|
|
every call (usual execution or every SP/PS call).
|
2005-07-01 06:05:42 +02:00
|
|
|
This method have to be called after WHERE preparation
|
2007-07-06 14:18:49 +02:00
|
|
|
(TABLE_LIST::prep_where)
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
RETURN
|
|
|
|
|
FALSE - OK
|
|
|
|
|
TRUE - error
|
|
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
bool TABLE_LIST::prep_check_option(THD *thd, uint8 check_opt_type)
|
2005-07-01 06:05:42 +02:00
|
|
|
{
|
2007-07-06 14:18:49 +02:00
|
|
|
DBUG_ENTER("TABLE_LIST::prep_check_option");
|
2007-05-31 23:15:40 +02:00
|
|
|
bool is_cascaded= check_opt_type == VIEW_CHECK_CASCADED;
|
2005-07-01 06:05:42 +02:00
|
|
|
|
2005-10-27 23:18:23 +02:00
|
|
|
for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
|
2004-09-14 18:28:29 +02:00
|
|
|
{
|
2005-07-01 06:05:42 +02:00
|
|
|
/* see comment of check_opt_type parameter */
|
2007-05-31 23:15:40 +02:00
|
|
|
if (tbl->view && tbl->prep_check_option(thd, (is_cascaded ?
|
|
|
|
|
VIEW_CHECK_CASCADED :
|
|
|
|
|
VIEW_CHECK_NONE)))
|
2005-07-01 06:05:42 +02:00
|
|
|
DBUG_RETURN(TRUE);
|
2004-09-14 18:28:29 +02:00
|
|
|
}
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2007-05-31 23:15:40 +02:00
|
|
|
if (check_opt_type && !check_option_processed)
|
2004-08-25 15:14:42 +02:00
|
|
|
{
|
2007-05-31 23:15:40 +02:00
|
|
|
Query_arena *arena= thd->stmt_arena, backup;
|
|
|
|
|
arena= thd->activate_stmt_arena_if_needed(&backup); // For easier test
|
|
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
if (where)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(where->fixed);
|
2007-05-31 23:15:40 +02:00
|
|
|
check_option= where->copy_andor_structure(thd);
|
2005-07-01 06:05:42 +02:00
|
|
|
}
|
2007-05-31 23:15:40 +02:00
|
|
|
if (is_cascaded)
|
2005-07-01 06:05:42 +02:00
|
|
|
{
|
2005-10-27 23:18:23 +02:00
|
|
|
for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
|
2005-07-01 06:05:42 +02:00
|
|
|
{
|
|
|
|
|
if (tbl->check_option)
|
2007-05-31 23:15:40 +02:00
|
|
|
check_option= and_conds(check_option, tbl->check_option);
|
2005-07-01 06:05:42 +02:00
|
|
|
}
|
|
|
|
|
}
|
2007-05-31 23:15:40 +02:00
|
|
|
check_option= and_conds(check_option,
|
|
|
|
|
merge_on_conds(thd, this, is_cascaded));
|
|
|
|
|
|
|
|
|
|
if (arena)
|
|
|
|
|
thd->restore_active_arena(arena, &backup);
|
|
|
|
|
check_option_processed= TRUE;
|
|
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (check_option)
|
|
|
|
|
{
|
|
|
|
|
const char *save_where= thd->where;
|
|
|
|
|
thd->where= "check option";
|
|
|
|
|
if (!check_option->fixed &&
|
|
|
|
|
check_option->fix_fields(thd, &check_option) ||
|
|
|
|
|
check_option->check_cols(1))
|
|
|
|
|
{
|
|
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
|
}
|
|
|
|
|
thd->where= save_where;
|
2004-08-25 15:14:42 +02:00
|
|
|
}
|
2005-07-01 06:05:42 +02:00
|
|
|
DBUG_RETURN(FALSE);
|
|
|
|
|
}
|
|
|
|
|
|
2004-08-25 15:14:42 +02:00
|
|
|
|
2007-12-12 16:21:01 +01:00
|
|
|
/**
|
2005-07-01 06:05:42 +02:00
|
|
|
Hide errors which show view underlying table information
|
|
|
|
|
|
2007-12-12 16:21:01 +01:00
|
|
|
@param[in,out] thd thread handler
|
2004-07-16 00:15:55 +02:00
|
|
|
|
2007-12-12 16:21:01 +01:00
|
|
|
@pre This method can be called only if there is an error.
|
2005-07-01 06:05:42 +02:00
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
void TABLE_LIST::hide_view_error(THD *thd)
|
2005-07-01 06:05:42 +02:00
|
|
|
{
|
2004-12-16 14:31:36 +01:00
|
|
|
/* Hide "Unknown column" or "Unknown function" error */
|
2007-12-12 16:21:01 +01:00
|
|
|
DBUG_ASSERT(thd->is_error());
|
|
|
|
|
|
|
|
|
|
if (thd->main_da.sql_errno() == ER_BAD_FIELD_ERROR ||
|
|
|
|
|
thd->main_da.sql_errno() == ER_SP_DOES_NOT_EXIST ||
|
|
|
|
|
thd->main_da.sql_errno() == ER_PROCACCESS_DENIED_ERROR ||
|
|
|
|
|
thd->main_da.sql_errno() == ER_COLUMNACCESS_DENIED_ERROR ||
|
|
|
|
|
thd->main_da.sql_errno() == ER_TABLEACCESS_DENIED_ERROR ||
|
|
|
|
|
thd->main_da.sql_errno() == ER_TABLE_NOT_LOCKED ||
|
|
|
|
|
thd->main_da.sql_errno() == ER_NO_SUCH_TABLE)
|
2004-07-21 03:26:20 +02:00
|
|
|
{
|
2005-10-27 23:18:23 +02:00
|
|
|
TABLE_LIST *top= top_table();
|
2007-12-12 16:21:01 +01:00
|
|
|
thd->clear_error();
|
2005-10-27 23:18:23 +02:00
|
|
|
my_error(ER_VIEW_INVALID, MYF(0), top->view_db.str, top->view_name.str);
|
2004-07-21 03:26:20 +02:00
|
|
|
}
|
2007-12-12 16:21:01 +01:00
|
|
|
else if (thd->main_da.sql_errno() == ER_NO_DEFAULT_FOR_FIELD)
|
2005-07-01 06:05:42 +02:00
|
|
|
{
|
2005-10-27 23:18:23 +02:00
|
|
|
TABLE_LIST *top= top_table();
|
2005-07-01 06:05:42 +02:00
|
|
|
thd->clear_error();
|
|
|
|
|
// TODO: make correct error message
|
2005-10-27 23:18:23 +02:00
|
|
|
my_error(ER_NO_DEFAULT_FOR_VIEW_FIELD, MYF(0),
|
|
|
|
|
top->view_db.str, top->view_name.str);
|
2005-07-01 06:05:42 +02:00
|
|
|
}
|
2004-07-16 00:15:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-04-03 00:23:45 +02:00
|
|
|
/*
|
|
|
|
|
Find underlying base tables (TABLE_LIST) which represent given
|
|
|
|
|
table_to_find (TABLE)
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::find_underlying_table()
|
2005-04-03 00:23:45 +02:00
|
|
|
table_to_find table to find
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
0 table is not found
|
|
|
|
|
found table reference
|
|
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST *TABLE_LIST::find_underlying_table(TABLE *table_to_find)
|
2005-04-03 00:23:45 +02:00
|
|
|
{
|
|
|
|
|
/* is this real table and table which we are looking for? */
|
2005-10-27 23:18:23 +02:00
|
|
|
if (table == table_to_find && merge_underlying_list == 0)
|
2005-04-03 00:23:45 +02:00
|
|
|
return this;
|
|
|
|
|
|
2005-10-27 23:18:23 +02:00
|
|
|
for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
|
2005-04-03 00:23:45 +02:00
|
|
|
{
|
|
|
|
|
TABLE_LIST *result;
|
|
|
|
|
if ((result= tbl->find_underlying_table(table_to_find)))
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2004-11-08 00:54:23 +01:00
|
|
|
/*
|
2008-10-07 23:34:00 +02:00
|
|
|
cleanup items belonged to view fields translation table
|
2004-11-08 00:54:23 +01:00
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::cleanup_items()
|
2004-11-08 00:54:23 +01:00
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
void TABLE_LIST::cleanup_items()
|
2004-11-08 00:54:23 +01:00
|
|
|
{
|
|
|
|
|
if (!field_translation)
|
|
|
|
|
return;
|
|
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
for (Field_translator *transl= field_translation;
|
|
|
|
|
transl < field_translation_end;
|
|
|
|
|
transl++)
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
transl->item->walk(&Item::cleanup_processor, 0, 0);
|
2004-11-08 00:54:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-09-29 15:35:01 +02:00
|
|
|
/*
|
|
|
|
|
check CHECK OPTION condition
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::view_check_option()
|
2004-09-29 15:35:01 +02:00
|
|
|
ignore_failure ignore check option fail
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
VIEW_CHECK_OK OK
|
|
|
|
|
VIEW_CHECK_ERROR FAILED
|
|
|
|
|
VIEW_CHECK_SKIP FAILED, but continue
|
|
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
int TABLE_LIST::view_check_option(THD *thd, bool ignore_failure)
|
2004-09-29 15:35:01 +02:00
|
|
|
{
|
|
|
|
|
if (check_option && check_option->val_int() == 0)
|
|
|
|
|
{
|
2006-12-14 23:51:37 +01:00
|
|
|
TABLE_LIST *main_view= top_table();
|
2004-09-29 15:35:01 +02:00
|
|
|
if (ignore_failure)
|
|
|
|
|
{
|
|
|
|
|
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
|
|
|
|
|
ER_VIEW_CHECK_FAILED, ER(ER_VIEW_CHECK_FAILED),
|
2006-12-14 23:51:37 +01:00
|
|
|
main_view->view_db.str, main_view->view_name.str);
|
2004-09-29 15:35:01 +02:00
|
|
|
return(VIEW_CHECK_SKIP);
|
|
|
|
|
}
|
2006-12-14 23:51:37 +01:00
|
|
|
my_error(ER_VIEW_CHECK_FAILED, MYF(0), main_view->view_db.str,
|
|
|
|
|
main_view->view_name.str);
|
|
|
|
|
return(VIEW_CHECK_ERROR);
|
2004-09-29 15:35:01 +02:00
|
|
|
}
|
|
|
|
|
return(VIEW_CHECK_OK);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-09-15 22:42:56 +02:00
|
|
|
/*
|
2004-11-25 08:28:32 +01:00
|
|
|
Find table in underlying tables by mask and check that only this
|
2004-11-21 18:33:49 +01:00
|
|
|
table belong to given mask
|
2004-09-15 22:42:56 +02:00
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::check_single_table()
|
2006-12-14 23:51:37 +01:00
|
|
|
table_arg reference on variable where to store found table
|
2004-09-15 22:42:56 +02:00
|
|
|
(should be 0 on call, to find table, or point to table for
|
|
|
|
|
unique test)
|
|
|
|
|
map bit mask of tables
|
2006-12-14 23:51:37 +01:00
|
|
|
view_arg view for which we are looking table
|
2004-09-15 22:42:56 +02:00
|
|
|
|
|
|
|
|
RETURN
|
2004-11-21 18:33:49 +01:00
|
|
|
FALSE table not found or found only one
|
|
|
|
|
TRUE found several tables
|
2004-09-15 22:42:56 +02:00
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
bool TABLE_LIST::check_single_table(TABLE_LIST **table_arg,
|
2006-12-14 23:51:37 +01:00
|
|
|
table_map map,
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST *view_arg)
|
2004-09-15 22:42:56 +02:00
|
|
|
{
|
2005-10-27 23:18:23 +02:00
|
|
|
for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
|
2004-09-15 22:42:56 +02:00
|
|
|
{
|
|
|
|
|
if (tbl->table)
|
|
|
|
|
{
|
|
|
|
|
if (tbl->table->map & map)
|
|
|
|
|
{
|
2006-12-14 23:51:37 +01:00
|
|
|
if (*table_arg)
|
2004-11-21 18:33:49 +01:00
|
|
|
return TRUE;
|
2006-12-14 23:51:37 +01:00
|
|
|
*table_arg= tbl;
|
|
|
|
|
tbl->check_option= view_arg->check_option;
|
2004-09-15 22:42:56 +02:00
|
|
|
}
|
|
|
|
|
}
|
2006-12-14 23:51:37 +01:00
|
|
|
else if (tbl->check_single_table(table_arg, map, view_arg))
|
2005-06-01 15:35:09 +02:00
|
|
|
return TRUE;
|
2004-09-15 22:42:56 +02:00
|
|
|
}
|
2004-11-21 18:33:49 +01:00
|
|
|
return FALSE;
|
2004-09-15 22:42:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Set insert_values buffer
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
set_insert_values()
|
|
|
|
|
mem_root memory pool for allocating
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
FALSE - OK
|
|
|
|
|
TRUE - out of memory
|
|
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
bool TABLE_LIST::set_insert_values(MEM_ROOT *mem_root)
|
2004-09-15 22:42:56 +02:00
|
|
|
{
|
|
|
|
|
if (table)
|
|
|
|
|
{
|
|
|
|
|
if (!table->insert_values &&
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
!(table->insert_values= (uchar *)alloc_root(mem_root,
|
2005-01-06 12:00:13 +01:00
|
|
|
table->s->rec_buff_length)))
|
2004-09-15 22:42:56 +02:00
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2005-10-27 23:18:23 +02:00
|
|
|
DBUG_ASSERT(view && merge_underlying_list);
|
|
|
|
|
for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
|
2004-09-15 22:42:56 +02:00
|
|
|
if (tbl->set_insert_values(mem_root))
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-08-12 16:57:19 +02:00
|
|
|
/*
|
|
|
|
|
Test if this is a leaf with respect to name resolution.
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::is_leaf_for_name_resolution()
|
2005-08-12 16:57:19 +02:00
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
A table reference is a leaf with respect to name resolution if
|
|
|
|
|
it is either a leaf node in a nested join tree (table, view,
|
|
|
|
|
schema table, subquery), or an inner node that represents a
|
|
|
|
|
NATURAL/USING join, or a nested join with materialized join
|
|
|
|
|
columns.
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
TRUE if a leaf, FALSE otherwise.
|
|
|
|
|
*/
|
2007-07-06 14:18:49 +02:00
|
|
|
bool TABLE_LIST::is_leaf_for_name_resolution()
|
2005-08-12 16:57:19 +02:00
|
|
|
{
|
|
|
|
|
return (view || is_natural_join || is_join_columns_complete ||
|
|
|
|
|
!nested_join);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Retrieve the first (left-most) leaf in a nested join tree with
|
|
|
|
|
respect to name resolution.
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::first_leaf_for_name_resolution()
|
2005-08-12 16:57:19 +02:00
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Given that 'this' is a nested table reference, recursively walk
|
|
|
|
|
down the left-most children of 'this' until we reach a leaf
|
|
|
|
|
table reference with respect to name resolution.
|
|
|
|
|
|
|
|
|
|
IMPLEMENTATION
|
|
|
|
|
The left-most child of a nested table reference is the last element
|
|
|
|
|
in the list of children because the children are inserted in
|
|
|
|
|
reverse order.
|
|
|
|
|
|
|
|
|
|
RETURN
|
2005-08-18 02:12:42 +02:00
|
|
|
If 'this' is a nested table reference - the left-most child of
|
2005-08-12 16:57:19 +02:00
|
|
|
the tree rooted in 'this',
|
2005-08-18 02:12:42 +02:00
|
|
|
else return 'this'
|
2005-08-12 16:57:19 +02:00
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST *TABLE_LIST::first_leaf_for_name_resolution()
|
2005-08-12 16:57:19 +02:00
|
|
|
{
|
2005-08-18 02:12:42 +02:00
|
|
|
TABLE_LIST *cur_table_ref;
|
|
|
|
|
NESTED_JOIN *cur_nested_join;
|
|
|
|
|
LINT_INIT(cur_table_ref);
|
2005-08-12 16:57:19 +02:00
|
|
|
|
2005-08-18 02:12:42 +02:00
|
|
|
if (is_leaf_for_name_resolution())
|
2005-08-12 16:57:19 +02:00
|
|
|
return this;
|
2005-08-18 02:12:42 +02:00
|
|
|
DBUG_ASSERT(nested_join);
|
2005-08-12 16:57:19 +02:00
|
|
|
|
2005-08-18 02:12:42 +02:00
|
|
|
for (cur_nested_join= nested_join;
|
|
|
|
|
cur_nested_join;
|
|
|
|
|
cur_nested_join= cur_table_ref->nested_join)
|
2005-08-12 16:57:19 +02:00
|
|
|
{
|
|
|
|
|
List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
|
|
|
|
|
cur_table_ref= it++;
|
|
|
|
|
/*
|
2005-09-30 09:39:17 +02:00
|
|
|
If the current nested join is a RIGHT JOIN, the operands in
|
|
|
|
|
'join_list' are in reverse order, thus the first operand is
|
|
|
|
|
already at the front of the list. Otherwise the first operand
|
|
|
|
|
is in the end of the list of join operands.
|
2005-08-12 16:57:19 +02:00
|
|
|
*/
|
|
|
|
|
if (!(cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
|
|
|
|
|
{
|
2005-08-18 02:12:42 +02:00
|
|
|
TABLE_LIST *next;
|
2005-08-12 16:57:19 +02:00
|
|
|
while ((next= it++))
|
|
|
|
|
cur_table_ref= next;
|
|
|
|
|
}
|
|
|
|
|
if (cur_table_ref->is_leaf_for_name_resolution())
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return cur_table_ref;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Retrieve the last (right-most) leaf in a nested join tree with
|
|
|
|
|
respect to name resolution.
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::last_leaf_for_name_resolution()
|
2005-08-12 16:57:19 +02:00
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Given that 'this' is a nested table reference, recursively walk
|
|
|
|
|
down the right-most children of 'this' until we reach a leaf
|
|
|
|
|
table reference with respect to name resolution.
|
|
|
|
|
|
|
|
|
|
IMPLEMENTATION
|
|
|
|
|
The right-most child of a nested table reference is the first
|
|
|
|
|
element in the list of children because the children are inserted
|
|
|
|
|
in reverse order.
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
- If 'this' is a nested table reference - the right-most child of
|
|
|
|
|
the tree rooted in 'this',
|
|
|
|
|
- else - 'this'
|
|
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST *TABLE_LIST::last_leaf_for_name_resolution()
|
2005-08-12 16:57:19 +02:00
|
|
|
{
|
|
|
|
|
TABLE_LIST *cur_table_ref= this;
|
2005-08-18 02:12:42 +02:00
|
|
|
NESTED_JOIN *cur_nested_join;
|
2005-08-12 16:57:19 +02:00
|
|
|
|
2005-08-18 02:12:42 +02:00
|
|
|
if (is_leaf_for_name_resolution())
|
2005-08-12 16:57:19 +02:00
|
|
|
return this;
|
2005-08-18 02:12:42 +02:00
|
|
|
DBUG_ASSERT(nested_join);
|
2005-08-12 16:57:19 +02:00
|
|
|
|
2005-08-18 02:12:42 +02:00
|
|
|
for (cur_nested_join= nested_join;
|
|
|
|
|
cur_nested_join;
|
|
|
|
|
cur_nested_join= cur_table_ref->nested_join)
|
2005-08-12 16:57:19 +02:00
|
|
|
{
|
2005-09-30 09:39:17 +02:00
|
|
|
cur_table_ref= cur_nested_join->join_list.head();
|
2005-08-12 16:57:19 +02:00
|
|
|
/*
|
2005-09-30 09:39:17 +02:00
|
|
|
If the current nested is a RIGHT JOIN, the operands in
|
|
|
|
|
'join_list' are in reverse order, thus the last operand is in the
|
|
|
|
|
end of the list.
|
2005-08-12 16:57:19 +02:00
|
|
|
*/
|
|
|
|
|
if ((cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
|
|
|
|
|
{
|
|
|
|
|
List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
|
2005-08-18 02:12:42 +02:00
|
|
|
TABLE_LIST *next;
|
2005-08-12 16:57:19 +02:00
|
|
|
cur_table_ref= it++;
|
|
|
|
|
while ((next= it++))
|
|
|
|
|
cur_table_ref= next;
|
|
|
|
|
}
|
|
|
|
|
if (cur_table_ref->is_leaf_for_name_resolution())
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return cur_table_ref;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-10-27 23:18:23 +02:00
|
|
|
/*
|
|
|
|
|
Register access mode which we need for underlying tables
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
register_want_access()
|
|
|
|
|
want_access Acess which we require
|
|
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
void TABLE_LIST::register_want_access(ulong want_access)
|
2005-10-27 23:18:23 +02:00
|
|
|
{
|
|
|
|
|
/* Remove SHOW_VIEW_ACL, because it will be checked during making view */
|
|
|
|
|
want_access&= ~SHOW_VIEW_ACL;
|
|
|
|
|
if (belong_to_view)
|
|
|
|
|
{
|
|
|
|
|
grant.want_privilege= want_access;
|
|
|
|
|
if (table)
|
|
|
|
|
table->grant.want_privilege= want_access;
|
|
|
|
|
}
|
|
|
|
|
for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
|
|
|
|
|
tbl->register_want_access(want_access);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2005-10-27 23:56:44 +02:00
|
|
|
Load security context information for this view
|
2005-10-27 23:18:23 +02:00
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::prepare_view_securety_context()
|
2005-10-27 23:18:23 +02:00
|
|
|
thd [in] thread handler
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
FALSE OK
|
|
|
|
|
TRUE Error
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef NO_EMBEDDED_ACCESS_CHECKS
|
2007-07-06 14:18:49 +02:00
|
|
|
bool TABLE_LIST::prepare_view_securety_context(THD *thd)
|
2005-10-27 23:18:23 +02:00
|
|
|
{
|
2007-07-06 14:18:49 +02:00
|
|
|
DBUG_ENTER("TABLE_LIST::prepare_view_securety_context");
|
2005-10-27 23:18:23 +02:00
|
|
|
DBUG_PRINT("enter", ("table: %s", alias));
|
|
|
|
|
|
|
|
|
|
DBUG_ASSERT(!prelocking_placeholder && view);
|
|
|
|
|
if (view_suid)
|
|
|
|
|
{
|
|
|
|
|
DBUG_PRINT("info", ("This table is suid view => load contest"));
|
|
|
|
|
DBUG_ASSERT(view && view_sctx);
|
|
|
|
|
if (acl_getroot_no_password(view_sctx,
|
|
|
|
|
definer.user.str,
|
|
|
|
|
definer.host.str,
|
|
|
|
|
definer.host.str,
|
|
|
|
|
thd->db))
|
|
|
|
|
{
|
2007-03-23 19:24:03 +01:00
|
|
|
if ((thd->lex->sql_command == SQLCOM_SHOW_CREATE) ||
|
|
|
|
|
(thd->lex->sql_command == SQLCOM_SHOW_FIELDS))
|
2006-05-26 10:49:39 +02:00
|
|
|
{
|
|
|
|
|
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
|
|
|
|
|
ER_NO_SUCH_USER,
|
|
|
|
|
ER(ER_NO_SUCH_USER),
|
|
|
|
|
definer.user.str, definer.host.str);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2006-11-27 14:15:32 +01:00
|
|
|
if (thd->security_ctx->master_access & SUPER_ACL)
|
|
|
|
|
{
|
|
|
|
|
my_error(ER_NO_SUCH_USER, MYF(0), definer.user.str, definer.host.str);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
|
|
|
|
|
thd->security_ctx->priv_user,
|
|
|
|
|
thd->security_ctx->priv_host,
|
|
|
|
|
(thd->password ? ER(ER_YES) : ER(ER_NO)));
|
|
|
|
|
}
|
2006-05-26 10:49:39 +02:00
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
|
}
|
2005-10-27 23:18:23 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
DBUG_RETURN(FALSE);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Find security context of current view
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::find_view_security_context()
|
2005-10-27 23:18:23 +02:00
|
|
|
thd [in] thread handler
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef NO_EMBEDDED_ACCESS_CHECKS
|
2007-07-06 14:18:49 +02:00
|
|
|
Security_context *TABLE_LIST::find_view_security_context(THD *thd)
|
2005-10-27 23:18:23 +02:00
|
|
|
{
|
|
|
|
|
Security_context *sctx;
|
|
|
|
|
TABLE_LIST *upper_view= this;
|
2007-07-06 14:18:49 +02:00
|
|
|
DBUG_ENTER("TABLE_LIST::find_view_security_context");
|
2005-10-27 23:18:23 +02:00
|
|
|
|
|
|
|
|
DBUG_ASSERT(view);
|
|
|
|
|
while (upper_view && !upper_view->view_suid)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(!upper_view->prelocking_placeholder);
|
|
|
|
|
upper_view= upper_view->referencing_view;
|
|
|
|
|
}
|
|
|
|
|
if (upper_view)
|
|
|
|
|
{
|
|
|
|
|
DBUG_PRINT("info", ("Securety context of view %s will be used",
|
|
|
|
|
upper_view->alias));
|
|
|
|
|
sctx= upper_view->view_sctx;
|
|
|
|
|
DBUG_ASSERT(sctx);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
DBUG_PRINT("info", ("Current global context will be used"));
|
|
|
|
|
sctx= thd->security_ctx;
|
|
|
|
|
}
|
|
|
|
|
DBUG_RETURN(sctx);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Prepare security context and load underlying tables priveleges for view
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::prepare_security()
|
2005-10-27 23:18:23 +02:00
|
|
|
thd [in] thread handler
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
FALSE OK
|
|
|
|
|
TRUE Error
|
|
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
bool TABLE_LIST::prepare_security(THD *thd)
|
2005-10-27 23:18:23 +02:00
|
|
|
{
|
|
|
|
|
List_iterator_fast<TABLE_LIST> tb(*view_tables);
|
|
|
|
|
TABLE_LIST *tbl;
|
2007-07-06 14:18:49 +02:00
|
|
|
DBUG_ENTER("TABLE_LIST::prepare_security");
|
2005-10-27 23:18:23 +02:00
|
|
|
#ifndef NO_EMBEDDED_ACCESS_CHECKS
|
|
|
|
|
Security_context *save_security_ctx= thd->security_ctx;
|
|
|
|
|
|
|
|
|
|
DBUG_ASSERT(!prelocking_placeholder);
|
|
|
|
|
if (prepare_view_securety_context(thd))
|
|
|
|
|
DBUG_RETURN(TRUE);
|
|
|
|
|
thd->security_ctx= find_view_security_context(thd);
|
|
|
|
|
while ((tbl= tb++))
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(tbl->referencing_view);
|
2006-12-14 23:51:37 +01:00
|
|
|
char *local_db, *local_table_name;
|
2005-10-27 23:18:23 +02:00
|
|
|
if (tbl->view)
|
|
|
|
|
{
|
2006-12-14 23:51:37 +01:00
|
|
|
local_db= tbl->view_db.str;
|
|
|
|
|
local_table_name= tbl->view_name.str;
|
2005-10-27 23:18:23 +02:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2006-12-14 23:51:37 +01:00
|
|
|
local_db= tbl->db;
|
|
|
|
|
local_table_name= tbl->table_name;
|
2005-10-27 23:18:23 +02:00
|
|
|
}
|
2006-12-14 23:51:37 +01:00
|
|
|
fill_effective_table_privileges(thd, &tbl->grant, local_db,
|
|
|
|
|
local_table_name);
|
2005-10-27 23:18:23 +02:00
|
|
|
if (tbl->table)
|
|
|
|
|
tbl->table->grant= grant;
|
|
|
|
|
}
|
|
|
|
|
thd->security_ctx= save_security_ctx;
|
|
|
|
|
#else
|
|
|
|
|
while ((tbl= tb++))
|
|
|
|
|
tbl->grant.privilege= ~NO_ACCESS;
|
|
|
|
|
#endif
|
2005-11-02 14:17:57 +01:00
|
|
|
DBUG_RETURN(FALSE);
|
2005-10-27 23:18:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-08-12 16:57:19 +02:00
|
|
|
Natural_join_column::Natural_join_column(Field_translator *field_param,
|
|
|
|
|
TABLE_LIST *tab)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(tab->field_translation);
|
|
|
|
|
view_field= field_param;
|
|
|
|
|
table_field= NULL;
|
|
|
|
|
table_ref= tab;
|
|
|
|
|
is_common= FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-10-07 23:34:00 +02:00
|
|
|
Natural_join_column::Natural_join_column(Item_field *field_param,
|
2005-08-12 16:57:19 +02:00
|
|
|
TABLE_LIST *tab)
|
|
|
|
|
{
|
2008-10-07 23:34:00 +02:00
|
|
|
DBUG_ASSERT(tab->table == field_param->field->table);
|
2005-08-12 16:57:19 +02:00
|
|
|
table_field= field_param;
|
|
|
|
|
view_field= NULL;
|
|
|
|
|
table_ref= tab;
|
|
|
|
|
is_common= FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *Natural_join_column::name()
|
|
|
|
|
{
|
|
|
|
|
if (view_field)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(table_field == NULL);
|
|
|
|
|
return view_field->name;
|
|
|
|
|
}
|
2005-08-18 02:12:42 +02:00
|
|
|
|
|
|
|
|
return table_field->field_name;
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Item *Natural_join_column::create_item(THD *thd)
|
|
|
|
|
{
|
|
|
|
|
if (view_field)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(table_field == NULL);
|
2005-08-18 02:12:42 +02:00
|
|
|
return create_view_field(thd, table_ref, &view_field->item,
|
|
|
|
|
view_field->name);
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
2008-10-07 23:34:00 +02:00
|
|
|
return table_field;
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Field *Natural_join_column::field()
|
|
|
|
|
{
|
|
|
|
|
if (view_field)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(table_field == NULL);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2008-10-07 23:34:00 +02:00
|
|
|
return table_field->field;
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *Natural_join_column::table_name()
|
|
|
|
|
{
|
2007-01-31 15:04:38 +01:00
|
|
|
DBUG_ASSERT(table_ref);
|
2005-08-12 16:57:19 +02:00
|
|
|
return table_ref->alias;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *Natural_join_column::db_name()
|
|
|
|
|
{
|
|
|
|
|
if (view_field)
|
|
|
|
|
return table_ref->view_db.str;
|
2005-08-18 02:12:42 +02:00
|
|
|
|
2006-02-22 09:04:10 +01:00
|
|
|
/*
|
|
|
|
|
Test that TABLE_LIST::db is the same as st_table_share::db to
|
|
|
|
|
ensure consistency. An exception are I_S schema tables, which
|
|
|
|
|
are inconsistent in this respect.
|
|
|
|
|
*/
|
2005-08-18 02:12:42 +02:00
|
|
|
DBUG_ASSERT(!strcmp(table_ref->db,
|
2006-03-03 12:03:27 +01:00
|
|
|
table_ref->table->s->db.str) ||
|
2006-02-22 09:04:10 +01:00
|
|
|
(table_ref->schema_table &&
|
2006-03-03 12:03:27 +01:00
|
|
|
table_ref->table->s->db.str[0] == 0));
|
2005-08-18 02:12:42 +02:00
|
|
|
return table_ref->db;
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
GRANT_INFO *Natural_join_column::grant()
|
|
|
|
|
{
|
|
|
|
|
if (view_field)
|
|
|
|
|
return &(table_ref->grant);
|
2005-08-18 02:12:42 +02:00
|
|
|
return &(table_ref->table->grant);
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-07-16 00:15:55 +02:00
|
|
|
void Field_iterator_view::set(TABLE_LIST *table)
|
|
|
|
|
{
|
2005-08-12 16:57:19 +02:00
|
|
|
DBUG_ASSERT(table->field_translation);
|
2005-07-01 06:05:42 +02:00
|
|
|
view= table;
|
2004-07-16 00:15:55 +02:00
|
|
|
ptr= table->field_translation;
|
2005-07-01 06:05:42 +02:00
|
|
|
array_end= table->field_translation_end;
|
2004-07-16 00:15:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *Field_iterator_table::name()
|
|
|
|
|
{
|
|
|
|
|
return (*ptr)->field_name;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
Item *Field_iterator_table::create_item(THD *thd)
|
2004-07-16 00:15:55 +02:00
|
|
|
{
|
2007-04-24 20:35:57 +02:00
|
|
|
SELECT_LEX *select= thd->lex->current_select;
|
|
|
|
|
|
|
|
|
|
Item_field *item= new Item_field(thd, &select->context, *ptr);
|
|
|
|
|
if (item && thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
|
|
|
|
|
!thd->lex->in_sum_func && select->cur_pos_in_select_list != UNDEF_POS)
|
|
|
|
|
{
|
|
|
|
|
select->non_agg_fields.push_back(item);
|
|
|
|
|
item->marker= select->cur_pos_in_select_list;
|
|
|
|
|
}
|
|
|
|
|
return item;
|
2004-07-16 00:15:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *Field_iterator_view::name()
|
|
|
|
|
{
|
2004-09-14 18:28:29 +02:00
|
|
|
return ptr->name;
|
2004-07-16 00:15:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
Item *Field_iterator_view::create_item(THD *thd)
|
|
|
|
|
{
|
|
|
|
|
return create_view_field(thd, view, &ptr->item, ptr->name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref,
|
|
|
|
|
const char *name)
|
|
|
|
|
{
|
|
|
|
|
bool save_wrapper= thd->lex->select_lex.no_wrap_view_item;
|
|
|
|
|
Item *field= *field_ref;
|
|
|
|
|
DBUG_ENTER("create_view_field");
|
|
|
|
|
|
|
|
|
|
if (view->schema_table_reformed)
|
|
|
|
|
{
|
|
|
|
|
/*
|
2005-11-28 20:57:50 +01:00
|
|
|
Translation table items are always Item_fields and already fixed
|
|
|
|
|
('mysql_schema_table' function). So we can return directly the
|
|
|
|
|
field. This case happens only for 'show & where' commands.
|
2005-07-01 06:05:42 +02:00
|
|
|
*/
|
|
|
|
|
DBUG_ASSERT(field && field->fixed);
|
|
|
|
|
DBUG_RETURN(field);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DBUG_ASSERT(field);
|
|
|
|
|
thd->lex->current_select->no_wrap_view_item= TRUE;
|
|
|
|
|
if (!field->fixed)
|
|
|
|
|
{
|
|
|
|
|
if (field->fix_fields(thd, field_ref))
|
|
|
|
|
{
|
|
|
|
|
thd->lex->current_select->no_wrap_view_item= save_wrapper;
|
|
|
|
|
DBUG_RETURN(0);
|
|
|
|
|
}
|
|
|
|
|
field= *field_ref;
|
|
|
|
|
}
|
|
|
|
|
thd->lex->current_select->no_wrap_view_item= save_wrapper;
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
if (save_wrapper)
|
2005-07-01 06:05:42 +02:00
|
|
|
{
|
|
|
|
|
DBUG_RETURN(field);
|
|
|
|
|
}
|
|
|
|
|
Item *item= new Item_direct_view_ref(&view->view->select_lex.context,
|
2005-10-01 08:35:30 +02:00
|
|
|
field_ref, view->alias,
|
2005-07-01 06:05:42 +02:00
|
|
|
name);
|
|
|
|
|
DBUG_RETURN(item);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-08-12 16:57:19 +02:00
|
|
|
void Field_iterator_natural_join::set(TABLE_LIST *table_ref)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(table_ref->join_columns);
|
2005-11-28 20:57:50 +01:00
|
|
|
column_ref_it.init(*(table_ref->join_columns));
|
|
|
|
|
cur_column_ref= column_ref_it++;
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-08-19 14:22:30 +02:00
|
|
|
void Field_iterator_natural_join::next()
|
|
|
|
|
{
|
2005-11-28 20:57:50 +01:00
|
|
|
cur_column_ref= column_ref_it++;
|
2005-08-22 00:13:37 +02:00
|
|
|
DBUG_ASSERT(!cur_column_ref || ! cur_column_ref->table_field ||
|
|
|
|
|
cur_column_ref->table_ref->table ==
|
2008-10-07 23:34:00 +02:00
|
|
|
cur_column_ref->table_field->field->table);
|
2005-08-19 14:22:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-08-12 16:57:19 +02:00
|
|
|
void Field_iterator_table_ref::set_field_iterator()
|
|
|
|
|
{
|
|
|
|
|
DBUG_ENTER("Field_iterator_table_ref::set_field_iterator");
|
|
|
|
|
/*
|
|
|
|
|
If the table reference we are iterating over is a natural join, or it is
|
|
|
|
|
an operand of a natural join, and TABLE_LIST::join_columns contains all
|
|
|
|
|
the columns of the join operand, then we pick the columns from
|
|
|
|
|
TABLE_LIST::join_columns, instead of the orginial container of the
|
|
|
|
|
columns of the join operator.
|
|
|
|
|
*/
|
|
|
|
|
if (table_ref->is_join_columns_complete)
|
|
|
|
|
{
|
|
|
|
|
/* Necesary, but insufficient conditions. */
|
|
|
|
|
DBUG_ASSERT(table_ref->is_natural_join ||
|
|
|
|
|
table_ref->nested_join ||
|
|
|
|
|
table_ref->join_columns &&
|
|
|
|
|
/* This is a merge view. */
|
|
|
|
|
((table_ref->field_translation &&
|
|
|
|
|
table_ref->join_columns->elements ==
|
|
|
|
|
(ulong)(table_ref->field_translation_end -
|
|
|
|
|
table_ref->field_translation)) ||
|
|
|
|
|
/* This is stored table or a tmptable view. */
|
|
|
|
|
(!table_ref->field_translation &&
|
|
|
|
|
table_ref->join_columns->elements ==
|
|
|
|
|
table_ref->table->s->fields)));
|
|
|
|
|
field_it= &natural_join_it;
|
|
|
|
|
DBUG_PRINT("info",("field_it for '%s' is Field_iterator_natural_join",
|
2005-08-18 10:28:50 +02:00
|
|
|
table_ref->alias));
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
/* This is a merge view, so use field_translation. */
|
|
|
|
|
else if (table_ref->field_translation)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(table_ref->view &&
|
|
|
|
|
table_ref->effective_algorithm == VIEW_ALGORITHM_MERGE);
|
|
|
|
|
field_it= &view_field_it;
|
|
|
|
|
DBUG_PRINT("info", ("field_it for '%s' is Field_iterator_view",
|
2005-08-18 10:28:50 +02:00
|
|
|
table_ref->alias));
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
/* This is a base table or stored view. */
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(table_ref->table || table_ref->view);
|
|
|
|
|
field_it= &table_field_it;
|
|
|
|
|
DBUG_PRINT("info", ("field_it for '%s' is Field_iterator_table",
|
2005-08-18 10:28:50 +02:00
|
|
|
table_ref->alias));
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
2005-08-18 02:12:42 +02:00
|
|
|
field_it->set(table_ref);
|
2005-08-12 16:57:19 +02:00
|
|
|
DBUG_VOID_RETURN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void Field_iterator_table_ref::set(TABLE_LIST *table)
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(table);
|
|
|
|
|
first_leaf= table->first_leaf_for_name_resolution();
|
|
|
|
|
last_leaf= table->last_leaf_for_name_resolution();
|
|
|
|
|
DBUG_ASSERT(first_leaf && last_leaf);
|
|
|
|
|
table_ref= first_leaf;
|
|
|
|
|
set_field_iterator();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void Field_iterator_table_ref::next()
|
|
|
|
|
{
|
|
|
|
|
/* Move to the next field in the current table reference. */
|
|
|
|
|
field_it->next();
|
|
|
|
|
/*
|
|
|
|
|
If all fields of the current table reference are exhausted, move to
|
|
|
|
|
the next leaf table reference.
|
|
|
|
|
*/
|
|
|
|
|
if (field_it->end_of_fields() && table_ref != last_leaf)
|
|
|
|
|
{
|
|
|
|
|
table_ref= table_ref->next_name_resolution_table;
|
|
|
|
|
DBUG_ASSERT(table_ref);
|
|
|
|
|
set_field_iterator();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-09-03 16:45:40 +02:00
|
|
|
const char *Field_iterator_table_ref::get_table_name()
|
2005-08-12 16:57:19 +02:00
|
|
|
{
|
|
|
|
|
if (table_ref->view)
|
|
|
|
|
return table_ref->view_name.str;
|
|
|
|
|
else if (table_ref->is_natural_join)
|
|
|
|
|
return natural_join_it.column_ref()->table_name();
|
2005-08-18 02:12:42 +02:00
|
|
|
|
|
|
|
|
DBUG_ASSERT(!strcmp(table_ref->table_name,
|
2005-11-23 21:45:02 +01:00
|
|
|
table_ref->table->s->table_name.str));
|
2005-08-18 02:12:42 +02:00
|
|
|
return table_ref->table_name;
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-09-03 16:45:40 +02:00
|
|
|
const char *Field_iterator_table_ref::get_db_name()
|
2005-08-12 16:57:19 +02:00
|
|
|
{
|
|
|
|
|
if (table_ref->view)
|
|
|
|
|
return table_ref->view_db.str;
|
|
|
|
|
else if (table_ref->is_natural_join)
|
|
|
|
|
return natural_join_it.column_ref()->db_name();
|
2005-08-18 02:12:42 +02:00
|
|
|
|
2006-02-22 09:04:10 +01:00
|
|
|
/*
|
|
|
|
|
Test that TABLE_LIST::db is the same as st_table_share::db to
|
|
|
|
|
ensure consistency. An exception are I_S schema tables, which
|
|
|
|
|
are inconsistent in this respect.
|
|
|
|
|
*/
|
2006-03-03 12:03:27 +01:00
|
|
|
DBUG_ASSERT(!strcmp(table_ref->db, table_ref->table->s->db.str) ||
|
2006-02-22 09:04:10 +01:00
|
|
|
(table_ref->schema_table &&
|
2006-03-03 12:03:27 +01:00
|
|
|
table_ref->table->s->db.str[0] == 0));
|
2006-02-22 09:04:10 +01:00
|
|
|
|
2005-08-18 02:12:42 +02:00
|
|
|
return table_ref->db;
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
GRANT_INFO *Field_iterator_table_ref::grant()
|
|
|
|
|
{
|
|
|
|
|
if (table_ref->view)
|
|
|
|
|
return &(table_ref->grant);
|
|
|
|
|
else if (table_ref->is_natural_join)
|
|
|
|
|
return natural_join_it.column_ref()->grant();
|
2005-08-18 02:12:42 +02:00
|
|
|
return &(table_ref->table->grant);
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Create new or return existing column reference to a column of a
|
|
|
|
|
natural/using join.
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
Field_iterator_table_ref::get_or_create_column_ref()
|
2006-03-02 10:50:15 +01:00
|
|
|
parent_table_ref the parent table reference over which the
|
|
|
|
|
iterator is iterating
|
2005-08-12 16:57:19 +02:00
|
|
|
|
|
|
|
|
DESCRIPTION
|
2006-03-02 10:50:15 +01:00
|
|
|
Create a new natural join column for the current field of the
|
|
|
|
|
iterator if no such column was created, or return an already
|
|
|
|
|
created natural join column. The former happens for base tables or
|
|
|
|
|
views, and the latter for natural/using joins. If a new field is
|
|
|
|
|
created, then the field is added to 'parent_table_ref' if it is
|
|
|
|
|
given, or to the original table referene of the field if
|
|
|
|
|
parent_table_ref == NULL.
|
|
|
|
|
|
|
|
|
|
NOTES
|
|
|
|
|
This method is designed so that when a Field_iterator_table_ref
|
|
|
|
|
walks through the fields of a table reference, all its fields
|
|
|
|
|
are created and stored as follows:
|
|
|
|
|
- If the table reference being iterated is a stored table, view or
|
|
|
|
|
natural/using join, store all natural join columns in a list
|
|
|
|
|
attached to that table reference.
|
|
|
|
|
- If the table reference being iterated is a nested join that is
|
|
|
|
|
not natural/using join, then do not materialize its result
|
|
|
|
|
fields. This is OK because for such table references
|
|
|
|
|
Field_iterator_table_ref iterates over the fields of the nested
|
|
|
|
|
table references (recursively). In this way we avoid the storage
|
|
|
|
|
of unnecessay copies of result columns of nested joins.
|
2005-08-12 16:57:19 +02:00
|
|
|
|
|
|
|
|
RETURN
|
2005-08-18 02:12:42 +02:00
|
|
|
# Pointer to a column of a natural join (or its operand)
|
|
|
|
|
NULL No memory to allocate the column
|
2005-08-12 16:57:19 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
Natural_join_column *
|
2008-10-07 23:34:00 +02:00
|
|
|
Field_iterator_table_ref::get_or_create_column_ref(THD *thd, TABLE_LIST *parent_table_ref)
|
2005-08-12 16:57:19 +02:00
|
|
|
{
|
2005-08-18 02:12:42 +02:00
|
|
|
Natural_join_column *nj_col;
|
2006-03-02 10:50:15 +01:00
|
|
|
bool is_created= TRUE;
|
|
|
|
|
uint field_count;
|
|
|
|
|
TABLE_LIST *add_table_ref= parent_table_ref ?
|
|
|
|
|
parent_table_ref : table_ref;
|
2006-03-29 13:27:36 +02:00
|
|
|
LINT_INIT(field_count);
|
2007-01-27 02:46:45 +01:00
|
|
|
|
2005-08-12 16:57:19 +02:00
|
|
|
if (field_it == &table_field_it)
|
2005-08-19 14:22:30 +02:00
|
|
|
{
|
|
|
|
|
/* The field belongs to a stored table. */
|
2006-12-14 23:51:37 +01:00
|
|
|
Field *tmp_field= table_field_it.field();
|
2008-10-07 23:34:00 +02:00
|
|
|
Item_field *tmp_item=
|
|
|
|
|
new Item_field(thd, &thd->lex->current_select->context, tmp_field);
|
|
|
|
|
if (!tmp_item)
|
|
|
|
|
return NULL;
|
|
|
|
|
nj_col= new Natural_join_column(tmp_item, table_ref);
|
2006-03-02 10:50:15 +01:00
|
|
|
field_count= table_ref->table->s->fields;
|
2005-08-19 14:22:30 +02:00
|
|
|
}
|
|
|
|
|
else if (field_it == &view_field_it)
|
|
|
|
|
{
|
|
|
|
|
/* The field belongs to a merge view or information schema table. */
|
|
|
|
|
Field_translator *translated_field= view_field_it.field_translator();
|
|
|
|
|
nj_col= new Natural_join_column(translated_field, table_ref);
|
2006-03-02 10:50:15 +01:00
|
|
|
field_count= table_ref->field_translation_end -
|
|
|
|
|
table_ref->field_translation;
|
2005-08-19 14:22:30 +02:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
The field belongs to a NATURAL join, therefore the column reference was
|
|
|
|
|
already created via one of the two constructor calls above. In this case
|
|
|
|
|
we just return the already created column reference.
|
|
|
|
|
*/
|
2006-03-02 10:50:15 +01:00
|
|
|
DBUG_ASSERT(table_ref->is_join_columns_complete);
|
|
|
|
|
is_created= FALSE;
|
2005-08-19 14:22:30 +02:00
|
|
|
nj_col= natural_join_it.column_ref();
|
|
|
|
|
DBUG_ASSERT(nj_col);
|
|
|
|
|
}
|
2005-08-22 00:13:37 +02:00
|
|
|
DBUG_ASSERT(!nj_col->table_field ||
|
2008-10-07 23:34:00 +02:00
|
|
|
nj_col->table_ref->table == nj_col->table_field->field->table);
|
2006-03-02 10:50:15 +01:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
If the natural join column was just created add it to the list of
|
|
|
|
|
natural join columns of either 'parent_table_ref' or to the table
|
|
|
|
|
reference that directly contains the original field.
|
|
|
|
|
*/
|
|
|
|
|
if (is_created)
|
|
|
|
|
{
|
|
|
|
|
/* Make sure not all columns were materialized. */
|
|
|
|
|
DBUG_ASSERT(!add_table_ref->is_join_columns_complete);
|
|
|
|
|
if (!add_table_ref->join_columns)
|
|
|
|
|
{
|
|
|
|
|
/* Create a list of natural join columns on demand. */
|
|
|
|
|
if (!(add_table_ref->join_columns= new List<Natural_join_column>))
|
|
|
|
|
return NULL;
|
|
|
|
|
add_table_ref->is_join_columns_complete= FALSE;
|
|
|
|
|
}
|
|
|
|
|
add_table_ref->join_columns->push_back(nj_col);
|
|
|
|
|
/*
|
|
|
|
|
If new fields are added to their original table reference, mark if
|
|
|
|
|
all fields were added. We do it here as the caller has no easy way
|
|
|
|
|
of knowing when to do it.
|
|
|
|
|
If the fields are being added to parent_table_ref, then the caller
|
|
|
|
|
must take care to mark when all fields are created/added.
|
|
|
|
|
*/
|
|
|
|
|
if (!parent_table_ref &&
|
|
|
|
|
add_table_ref->join_columns->elements == field_count)
|
|
|
|
|
add_table_ref->is_join_columns_complete= TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2005-08-18 02:12:42 +02:00
|
|
|
return nj_col;
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-11-28 20:57:50 +01:00
|
|
|
/*
|
|
|
|
|
Return an existing reference to a column of a natural/using join.
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
Field_iterator_table_ref::get_natural_column_ref()
|
|
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
The method should be called in contexts where it is expected that
|
|
|
|
|
all natural join columns are already created, and that the column
|
|
|
|
|
being retrieved is a Natural_join_column.
|
|
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
# Pointer to a column of a natural join (or its operand)
|
|
|
|
|
NULL No memory to allocate the column
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
Natural_join_column *
|
|
|
|
|
Field_iterator_table_ref::get_natural_column_ref()
|
|
|
|
|
{
|
|
|
|
|
Natural_join_column *nj_col;
|
|
|
|
|
|
|
|
|
|
DBUG_ASSERT(field_it == &natural_join_it);
|
|
|
|
|
/*
|
|
|
|
|
The field belongs to a NATURAL join, therefore the column reference was
|
|
|
|
|
already created via one of the two constructor calls above. In this case
|
|
|
|
|
we just return the already created column reference.
|
|
|
|
|
*/
|
|
|
|
|
nj_col= natural_join_it.column_ref();
|
|
|
|
|
DBUG_ASSERT(nj_col &&
|
|
|
|
|
(!nj_col->table_field ||
|
2008-10-07 23:34:00 +02:00
|
|
|
nj_col->table_ref->table == nj_col->table_field->field->table));
|
2005-11-28 20:57:50 +01:00
|
|
|
return nj_col;
|
|
|
|
|
}
|
|
|
|
|
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
|
Functions to handle column usage bitmaps (read_set, write_set etc...)
|
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
|
|
/* Reset all columns bitmaps */
|
|
|
|
|
|
|
|
|
|
void st_table::clear_column_bitmaps()
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
Reset column read/write usage. It's identical to:
|
|
|
|
|
bitmap_clear_all(&table->def_read_set);
|
|
|
|
|
bitmap_clear_all(&table->def_write_set);
|
|
|
|
|
*/
|
|
|
|
|
bzero((char*) def_read_set.bitmap, s->column_bitmap_size*2);
|
|
|
|
|
column_bitmaps_set(&def_read_set, &def_write_set);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Tell handler we are going to call position() and rnd_pos() later.
|
|
|
|
|
|
|
|
|
|
NOTES:
|
|
|
|
|
This is needed for handlers that uses the primary key to find the
|
|
|
|
|
row. In this case we have to extend the read bitmap with the primary
|
|
|
|
|
key fields.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void st_table::prepare_for_position()
|
|
|
|
|
{
|
|
|
|
|
DBUG_ENTER("st_table::prepare_for_position");
|
|
|
|
|
|
|
|
|
|
if ((file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
|
|
|
|
|
s->primary_key < MAX_KEY)
|
|
|
|
|
{
|
|
|
|
|
mark_columns_used_by_index_no_reset(s->primary_key, read_set);
|
|
|
|
|
/* signal change */
|
|
|
|
|
file->column_bitmaps_signal();
|
|
|
|
|
}
|
|
|
|
|
DBUG_VOID_RETURN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Mark that only fields from one key is used
|
|
|
|
|
|
|
|
|
|
NOTE:
|
|
|
|
|
This changes the bitmap to use the tmp bitmap
|
|
|
|
|
After this, you can't access any other columns in the table until
|
|
|
|
|
bitmaps are reset, for example with st_table::clear_column_bitmaps()
|
|
|
|
|
or st_table::restore_column_maps_after_mark_index()
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void st_table::mark_columns_used_by_index(uint index)
|
|
|
|
|
{
|
|
|
|
|
MY_BITMAP *bitmap= &tmp_set;
|
|
|
|
|
DBUG_ENTER("st_table::mark_columns_used_by_index");
|
|
|
|
|
|
|
|
|
|
(void) file->extra(HA_EXTRA_KEYREAD);
|
|
|
|
|
bitmap_clear_all(bitmap);
|
|
|
|
|
mark_columns_used_by_index_no_reset(index, bitmap);
|
|
|
|
|
column_bitmaps_set(bitmap, bitmap);
|
|
|
|
|
DBUG_VOID_RETURN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Restore to use normal column maps after key read
|
|
|
|
|
|
|
|
|
|
NOTES
|
|
|
|
|
This reverse the change done by mark_columns_used_by_index
|
|
|
|
|
|
|
|
|
|
WARNING
|
|
|
|
|
For this to work, one must have the normal table maps in place
|
|
|
|
|
when calling mark_columns_used_by_index
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void st_table::restore_column_maps_after_mark_index()
|
|
|
|
|
{
|
|
|
|
|
DBUG_ENTER("st_table::restore_column_maps_after_mark_index");
|
|
|
|
|
|
|
|
|
|
key_read= 0;
|
|
|
|
|
(void) file->extra(HA_EXTRA_NO_KEYREAD);
|
|
|
|
|
default_column_bitmaps();
|
|
|
|
|
file->column_bitmaps_signal();
|
|
|
|
|
DBUG_VOID_RETURN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
mark columns used by key, but don't reset other fields
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void st_table::mark_columns_used_by_index_no_reset(uint index,
|
|
|
|
|
MY_BITMAP *bitmap)
|
|
|
|
|
{
|
|
|
|
|
KEY_PART_INFO *key_part= key_info[index].key_part;
|
|
|
|
|
KEY_PART_INFO *key_part_end= (key_part +
|
|
|
|
|
key_info[index].key_parts);
|
|
|
|
|
for (;key_part != key_part_end; key_part++)
|
|
|
|
|
bitmap_set_bit(bitmap, key_part->fieldnr-1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Mark auto-increment fields as used fields in both read and write maps
|
|
|
|
|
|
|
|
|
|
NOTES
|
|
|
|
|
This is needed in insert & update as the auto-increment field is
|
|
|
|
|
always set and sometimes read.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void st_table::mark_auto_increment_column()
|
|
|
|
|
{
|
|
|
|
|
DBUG_ASSERT(found_next_number_field);
|
|
|
|
|
/*
|
|
|
|
|
We must set bit in read set as update_auto_increment() is using the
|
|
|
|
|
store() to check overflow of auto_increment values
|
|
|
|
|
*/
|
|
|
|
|
bitmap_set_bit(read_set, found_next_number_field->field_index);
|
|
|
|
|
bitmap_set_bit(write_set, found_next_number_field->field_index);
|
2007-01-29 10:40:26 +01:00
|
|
|
if (s->next_number_keypart)
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
mark_columns_used_by_index_no_reset(s->next_number_index, read_set);
|
|
|
|
|
file->column_bitmaps_signal();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Mark columns needed for doing an delete of a row
|
|
|
|
|
|
|
|
|
|
DESCRIPTON
|
|
|
|
|
Some table engines don't have a cursor on the retrieve rows
|
|
|
|
|
so they need either to use the primary key or all columns to
|
|
|
|
|
be able to delete a row.
|
|
|
|
|
|
|
|
|
|
If the engine needs this, the function works as follows:
|
|
|
|
|
- If primary key exits, mark the primary key columns to be read.
|
|
|
|
|
- If not, mark all columns to be read
|
|
|
|
|
|
|
|
|
|
If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
|
|
|
|
|
mark all key columns as 'to-be-read'. This allows the engine to
|
|
|
|
|
loop over the given record to find all keys and doesn't have to
|
|
|
|
|
retrieve the row again.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void st_table::mark_columns_needed_for_delete()
|
|
|
|
|
{
|
|
|
|
|
if (triggers)
|
2006-07-06 11:33:23 +02:00
|
|
|
triggers->mark_fields_used(TRG_EVENT_DELETE);
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
|
|
|
|
|
{
|
|
|
|
|
Field **reg_field;
|
|
|
|
|
for (reg_field= field ; *reg_field ; reg_field++)
|
|
|
|
|
{
|
|
|
|
|
if ((*reg_field)->flags & PART_KEY_FLAG)
|
|
|
|
|
bitmap_set_bit(read_set, (*reg_field)->field_index);
|
|
|
|
|
}
|
|
|
|
|
file->column_bitmaps_signal();
|
|
|
|
|
}
|
|
|
|
|
if (file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_DELETE)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
If the handler has no cursor capabilites, we have to read either
|
|
|
|
|
the primary key, the hidden primary key or all columns to be
|
|
|
|
|
able to do an delete
|
|
|
|
|
*/
|
|
|
|
|
if (s->primary_key == MAX_KEY)
|
|
|
|
|
file->use_hidden_primary_key();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
mark_columns_used_by_index_no_reset(s->primary_key, read_set);
|
|
|
|
|
file->column_bitmaps_signal();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Mark columns needed for doing an update of a row
|
|
|
|
|
|
|
|
|
|
DESCRIPTON
|
|
|
|
|
Some engines needs to have all columns in an update (to be able to
|
|
|
|
|
build a complete row). If this is the case, we mark all not
|
|
|
|
|
updated columns to be read.
|
|
|
|
|
|
|
|
|
|
If this is no the case, we do like in the delete case and mark
|
|
|
|
|
if neeed, either the primary key column or all columns to be read.
|
|
|
|
|
(see mark_columns_needed_for_delete() for details)
|
|
|
|
|
|
|
|
|
|
If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
|
|
|
|
|
mark all USED key columns as 'to-be-read'. This allows the engine to
|
|
|
|
|
loop over the given record to find all changed keys and doesn't have to
|
|
|
|
|
retrieve the row again.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void st_table::mark_columns_needed_for_update()
|
|
|
|
|
{
|
|
|
|
|
DBUG_ENTER("mark_columns_needed_for_update");
|
|
|
|
|
if (triggers)
|
2006-07-06 11:33:23 +02:00
|
|
|
triggers->mark_fields_used(TRG_EVENT_UPDATE);
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
|
|
|
|
|
{
|
|
|
|
|
/* Mark all used key columns for read */
|
|
|
|
|
Field **reg_field;
|
|
|
|
|
for (reg_field= field ; *reg_field ; reg_field++)
|
|
|
|
|
{
|
|
|
|
|
/* Merge keys is all keys that had a column refered to in the query */
|
|
|
|
|
if (merge_keys.is_overlapping((*reg_field)->part_of_key))
|
|
|
|
|
bitmap_set_bit(read_set, (*reg_field)->field_index);
|
|
|
|
|
}
|
|
|
|
|
file->column_bitmaps_signal();
|
|
|
|
|
}
|
|
|
|
|
if (file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_DELETE)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
If the handler has no cursor capabilites, we have to read either
|
|
|
|
|
the primary key, the hidden primary key or all columns to be
|
|
|
|
|
able to do an update
|
|
|
|
|
*/
|
|
|
|
|
if (s->primary_key == MAX_KEY)
|
|
|
|
|
file->use_hidden_primary_key();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
mark_columns_used_by_index_no_reset(s->primary_key, read_set);
|
|
|
|
|
file->column_bitmaps_signal();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
DBUG_VOID_RETURN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Mark columns the handler needs for doing an insert
|
|
|
|
|
|
|
|
|
|
For now, this is used to mark fields used by the trigger
|
|
|
|
|
as changed.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void st_table::mark_columns_needed_for_insert()
|
|
|
|
|
{
|
|
|
|
|
if (triggers)
|
|
|
|
|
{
|
2006-07-06 11:33:23 +02:00
|
|
|
/*
|
|
|
|
|
We don't need to mark columns which are used by ON DELETE and
|
|
|
|
|
ON UPDATE triggers, which may be invoked in case of REPLACE or
|
|
|
|
|
INSERT ... ON DUPLICATE KEY UPDATE, since before doing actual
|
|
|
|
|
row replacement or update write_record() will mark all table
|
|
|
|
|
fields as used.
|
|
|
|
|
*/
|
|
|
|
|
triggers->mark_fields_used(TRG_EVENT_INSERT);
|
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.
2006-06-04 17:52:22 +02:00
|
|
|
}
|
|
|
|
|
if (found_next_number_field)
|
|
|
|
|
mark_auto_increment_column();
|
|
|
|
|
}
|
|
|
|
|
|
Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
corrupts a MERGE table
Bug 26867 - LOCK TABLES + REPAIR + merge table result in
memory/cpu hogging
Bug 26377 - Deadlock with MERGE and FLUSH TABLE
Bug 25038 - Waiting TRUNCATE
Bug 25700 - merge base tables get corrupted by
optimize/analyze/repair table
Bug 30275 - Merge tables: flush tables or unlock tables
causes server to crash
Bug 19627 - temporary merge table locking
Bug 27660 - Falcon: merge table possible
Bug 30273 - merge tables: Can't lock file (errno: 155)
The problems were:
Bug 26379 - Combination of FLUSH TABLE and REPAIR TABLE
corrupts a MERGE table
1. A thread trying to lock a MERGE table performs busy waiting while
REPAIR TABLE or a similar table administration task is ongoing on
one or more of its MyISAM tables.
2. A thread trying to lock a MERGE table performs busy waiting until all
threads that did REPAIR TABLE or similar table administration tasks
on one or more of its MyISAM tables in LOCK TABLES segments do UNLOCK
TABLES. The difference against problem #1 is that the busy waiting
takes place *after* the administration task. It is terminated by
UNLOCK TABLES only.
3. Two FLUSH TABLES within a LOCK TABLES segment can invalidate the
lock. This does *not* require a MERGE table. The first FLUSH TABLES
can be replaced by any statement that requires other threads to
reopen the table. In 5.0 and 5.1 a single FLUSH TABLES can provoke
the problem.
Bug 26867 - LOCK TABLES + REPAIR + merge table result in
memory/cpu hogging
Trying DML on a MERGE table, which has a child locked and
repaired by another thread, made an infinite loop in the server.
Bug 26377 - Deadlock with MERGE and FLUSH TABLE
Locking a MERGE table and its children in parent-child order
and flushing the child deadlocked the server.
Bug 25038 - Waiting TRUNCATE
Truncating a MERGE child, while the MERGE table was in use,
let the truncate fail instead of waiting for the table to
become free.
Bug 25700 - merge base tables get corrupted by
optimize/analyze/repair table
Repairing a child of an open MERGE table corrupted the child.
It was necessary to FLUSH the child first.
Bug 30275 - Merge tables: flush tables or unlock tables
causes server to crash
Flushing and optimizing locked MERGE children crashed the server.
Bug 19627 - temporary merge table locking
Use of a temporary MERGE table with non-temporary children
could corrupt the children.
Temporary tables are never locked. So we do now prohibit
non-temporary chidlren of a temporary MERGE table.
Bug 27660 - Falcon: merge table possible
It was possible to create a MERGE table with non-MyISAM children.
Bug 30273 - merge tables: Can't lock file (errno: 155)
This was a Windows-only bug. Table administration statements
sometimes failed with "Can't lock file (errno: 155)".
These bugs are fixed by a new implementation of MERGE table open.
When opening a MERGE table in open_tables() we do now add the
child tables to the list of tables to be opened by open_tables()
(the "query_list"). The children are not opened in the handler at
this stage.
After opening the parent, open_tables() opens each child from the
now extended query_list. When the last child is opened, we remove
the children from the query_list again and attach the children to
the parent. This behaves similar to the old open. However it does
not open the MyISAM tables directly, but grabs them from the already
open children.
When closing a MERGE table in close_thread_table() we detach the
children only. Closing of the children is done implicitly because
they are in thd->open_tables.
For more detail see the comment at the top of ha_myisammrg.cc.
Changed from open_ltable() to open_and_lock_tables() in all places
that can be relevant for MERGE tables. The latter can handle tables
added to the list on the fly. When open_ltable() was used in a loop
over a list of tables, the list must be temporarily terminated
after every table for open_and_lock_tables().
table_list->required_type is set to FRMTYPE_TABLE to avoid open of
special tables. Handling of derived tables is suppressed.
These details are handled by the new function
open_n_lock_single_table(), which has nearly the same signature as
open_ltable() and can replace it in most cases.
In reopen_tables() some of the tables open by a thread can be
closed and reopened. When a MERGE child is affected, the parent
must be closed and reopened too. Closing of the parent is forced
before the first child is closed. Reopen happens in the order of
thd->open_tables. MERGE parents do not attach their children
automatically at open. This is done after all tables are reopened.
So all children are open when attaching them.
Special lock handling like mysql_lock_abort() or mysql_lock_remove()
needs to be suppressed for MERGE children or forwarded to the parent.
This depends on the situation. In loops over all open tables one
suppresses child lock handling. When a single table is touched,
forwarding is done.
Behavioral changes:
===================
This patch changes the behavior of temporary MERGE tables.
Temporary MERGE must have temporary children.
The old behavior was wrong. A temporary table is not locked. Hence
even non-temporary children were not locked. See
Bug 19627 - temporary merge table locking.
You cannot change the union list of a non-temporary MERGE table
when LOCK TABLES is in effect. The following does *not* work:
CREATE TABLE m1 ... ENGINE=MRG_MYISAM ...;
LOCK TABLES t1 WRITE, t2 WRITE, m1 WRITE;
ALTER TABLE m1 ... UNION=(t1,t2) ...;
However, you can do this with a temporary MERGE table.
You cannot create a MERGE table with CREATE ... SELECT, neither
as a temporary MERGE table, nor as a non-temporary MERGE table.
CREATE TABLE m1 ... ENGINE=MRG_MYISAM ... SELECT ...;
Gives error message: table is not BASE TABLE.
2007-11-15 20:25:43 +01:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@brief Check if this is part of a MERGE table with attached children.
|
|
|
|
|
|
|
|
|
|
@return status
|
|
|
|
|
@retval TRUE children are attached
|
|
|
|
|
@retval FALSE no MERGE part or children not attached
|
|
|
|
|
|
|
|
|
|
@detail
|
|
|
|
|
A MERGE table consists of a parent TABLE and zero or more child
|
|
|
|
|
TABLEs. Each of these TABLEs is called a part of a MERGE table.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
bool st_table::is_children_attached(void)
|
|
|
|
|
{
|
|
|
|
|
return((child_l && children_attached) ||
|
|
|
|
|
(parent && parent->children_attached));
|
|
|
|
|
}
|
|
|
|
|
|
2006-07-06 21:59:04 +02:00
|
|
|
/*
|
|
|
|
|
Cleanup this table for re-execution.
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::reinit_before_use()
|
2006-07-06 21:59:04 +02:00
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
void TABLE_LIST::reinit_before_use(THD *thd)
|
2006-07-06 21:59:04 +02:00
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
Reset old pointers to TABLEs: they are not valid since the tables
|
|
|
|
|
were closed in the end of previous prepare or execute call.
|
|
|
|
|
*/
|
|
|
|
|
table= 0;
|
2006-07-11 21:39:51 +02:00
|
|
|
/* Reset is_schema_table_processed value(needed for I_S tables */
|
2007-02-12 13:06:14 +01:00
|
|
|
schema_table_state= NOT_PROCESSED;
|
2006-07-11 21:39:51 +02:00
|
|
|
|
|
|
|
|
TABLE_LIST *embedded; /* The table at the current level of nesting. */
|
2006-12-14 23:51:37 +01:00
|
|
|
TABLE_LIST *parent_embedding= this; /* The parent nested table reference. */
|
2006-07-11 21:39:51 +02:00
|
|
|
do
|
|
|
|
|
{
|
2006-12-14 23:51:37 +01:00
|
|
|
embedded= parent_embedding;
|
2006-07-11 21:39:51 +02:00
|
|
|
if (embedded->prep_on_expr)
|
|
|
|
|
embedded->on_expr= embedded->prep_on_expr->copy_andor_structure(thd);
|
2006-12-14 23:51:37 +01:00
|
|
|
parent_embedding= embedded->embedding;
|
2006-07-11 21:39:51 +02:00
|
|
|
}
|
2006-12-14 23:51:37 +01:00
|
|
|
while (parent_embedding &&
|
|
|
|
|
parent_embedding->nested_join->join_list.head() == embedded);
|
2006-07-06 21:59:04 +02:00
|
|
|
}
|
|
|
|
|
|
2006-11-01 02:31:56 +01:00
|
|
|
/*
|
|
|
|
|
Return subselect that contains the FROM list this table is taken from
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2007-07-06 14:18:49 +02:00
|
|
|
TABLE_LIST::containing_subselect()
|
2006-11-01 02:31:56 +01:00
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
Subselect item for the subquery that contains the FROM list
|
|
|
|
|
this table is taken from if there is any
|
|
|
|
|
0 - otherwise
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
2007-07-06 14:18:49 +02:00
|
|
|
Item_subselect *TABLE_LIST::containing_subselect()
|
2006-11-01 02:31:56 +01:00
|
|
|
{
|
|
|
|
|
return (select_lex ? select_lex->master_unit()->item : 0);
|
|
|
|
|
}
|
2005-11-28 20:57:50 +01:00
|
|
|
|
2007-03-05 18:08:41 +01:00
|
|
|
/*
|
|
|
|
|
Compiles the tagged hints list and fills up the bitmasks.
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
process_index_hints()
|
|
|
|
|
table the TABLE to operate on.
|
|
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
The parser collects the index hints for each table in a "tagged list"
|
2007-07-16 22:59:21 +02:00
|
|
|
(TABLE_LIST::index_hints). Using the information in this tagged list
|
2007-03-05 18:08:41 +01:00
|
|
|
this function sets the members st_table::keys_in_use_for_query,
|
|
|
|
|
st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
|
|
|
|
|
st_table::force_index and st_table::covering_keys.
|
|
|
|
|
|
|
|
|
|
Current implementation of the runtime does not allow mixing FORCE INDEX
|
|
|
|
|
and USE INDEX, so this is checked here. Then the FORCE INDEX list
|
|
|
|
|
(if non-empty) is appended to the USE INDEX list and a flag is set.
|
|
|
|
|
|
|
|
|
|
Multiple hints of the same kind are processed so that each clause
|
|
|
|
|
is applied to what is computed in the previous clause.
|
|
|
|
|
For example:
|
|
|
|
|
USE INDEX (i1) USE INDEX (i2)
|
|
|
|
|
is equivalent to
|
|
|
|
|
USE INDEX (i1,i2)
|
|
|
|
|
and means "consider only i1 and i2".
|
|
|
|
|
|
|
|
|
|
Similarly
|
|
|
|
|
USE INDEX () USE INDEX (i1)
|
|
|
|
|
is equivalent to
|
|
|
|
|
USE INDEX (i1)
|
|
|
|
|
and means "consider only the index i1"
|
|
|
|
|
|
|
|
|
|
It is OK to have the same index several times, e.g. "USE INDEX (i1,i1)" is
|
|
|
|
|
not an error.
|
|
|
|
|
|
|
|
|
|
Different kind of hints (USE/FORCE/IGNORE) are processed in the following
|
|
|
|
|
order:
|
|
|
|
|
1. All indexes in USE (or FORCE) INDEX are added to the mask.
|
|
|
|
|
2. All IGNORE INDEX
|
|
|
|
|
|
|
|
|
|
e.g. "USE INDEX i1, IGNORE INDEX i1, USE INDEX i1" will not use i1 at all
|
|
|
|
|
as if we had "USE INDEX i1, USE INDEX i1, IGNORE INDEX i1".
|
|
|
|
|
|
|
|
|
|
As an optimization if there is a covering index, and we have
|
|
|
|
|
IGNORE INDEX FOR GROUP/ORDER, and this index is used for the JOIN part,
|
|
|
|
|
then we have to ignore the IGNORE INDEX FROM GROUP/ORDER.
|
|
|
|
|
|
|
|
|
|
RETURN VALUE
|
|
|
|
|
FALSE no errors found
|
|
|
|
|
TRUE found and reported an error.
|
|
|
|
|
*/
|
2007-08-13 15:11:25 +02:00
|
|
|
bool TABLE_LIST::process_index_hints(TABLE *tbl)
|
2007-03-05 18:08:41 +01:00
|
|
|
{
|
|
|
|
|
/* initialize the result variables */
|
2007-08-13 15:11:25 +02:00
|
|
|
tbl->keys_in_use_for_query= tbl->keys_in_use_for_group_by=
|
|
|
|
|
tbl->keys_in_use_for_order_by= tbl->s->keys_in_use;
|
2007-03-05 18:08:41 +01:00
|
|
|
|
|
|
|
|
/* index hint list processing */
|
|
|
|
|
if (index_hints)
|
|
|
|
|
{
|
|
|
|
|
key_map index_join[INDEX_HINT_FORCE + 1];
|
|
|
|
|
key_map index_order[INDEX_HINT_FORCE + 1];
|
|
|
|
|
key_map index_group[INDEX_HINT_FORCE + 1];
|
2007-07-23 18:09:48 +02:00
|
|
|
Index_hint *hint;
|
2007-03-05 18:08:41 +01:00
|
|
|
int type;
|
|
|
|
|
bool have_empty_use_join= FALSE, have_empty_use_order= FALSE,
|
|
|
|
|
have_empty_use_group= FALSE;
|
2007-07-23 18:09:48 +02:00
|
|
|
List_iterator <Index_hint> iter(*index_hints);
|
2007-03-05 18:08:41 +01:00
|
|
|
|
|
|
|
|
/* initialize temporary variables used to collect hints of each kind */
|
|
|
|
|
for (type= INDEX_HINT_IGNORE; type <= INDEX_HINT_FORCE; type++)
|
|
|
|
|
{
|
|
|
|
|
index_join[type].clear_all();
|
|
|
|
|
index_order[type].clear_all();
|
|
|
|
|
index_group[type].clear_all();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* iterate over the hints list */
|
|
|
|
|
while ((hint= iter++))
|
|
|
|
|
{
|
|
|
|
|
uint pos;
|
|
|
|
|
|
|
|
|
|
/* process empty USE INDEX () */
|
|
|
|
|
if (hint->type == INDEX_HINT_USE && !hint->key_name.str)
|
|
|
|
|
{
|
|
|
|
|
if (hint->clause & INDEX_HINT_MASK_JOIN)
|
|
|
|
|
{
|
|
|
|
|
index_join[hint->type].clear_all();
|
|
|
|
|
have_empty_use_join= TRUE;
|
|
|
|
|
}
|
|
|
|
|
if (hint->clause & INDEX_HINT_MASK_ORDER)
|
|
|
|
|
{
|
|
|
|
|
index_order[hint->type].clear_all();
|
|
|
|
|
have_empty_use_order= TRUE;
|
|
|
|
|
}
|
|
|
|
|
if (hint->clause & INDEX_HINT_MASK_GROUP)
|
|
|
|
|
{
|
|
|
|
|
index_group[hint->type].clear_all();
|
|
|
|
|
have_empty_use_group= TRUE;
|
|
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Check if an index with the given name exists and get his offset in
|
|
|
|
|
the keys bitmask for the table
|
|
|
|
|
*/
|
2007-08-13 15:11:25 +02:00
|
|
|
if (tbl->s->keynames.type_names == 0 ||
|
|
|
|
|
(pos= find_type(&tbl->s->keynames, hint->key_name.str,
|
2007-03-05 18:08:41 +01:00
|
|
|
hint->key_name.length, 1)) <= 0)
|
|
|
|
|
{
|
|
|
|
|
my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), hint->key_name.str, alias);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pos--;
|
|
|
|
|
|
|
|
|
|
/* add to the appropriate clause mask */
|
|
|
|
|
if (hint->clause & INDEX_HINT_MASK_JOIN)
|
|
|
|
|
index_join[hint->type].set_bit (pos);
|
|
|
|
|
if (hint->clause & INDEX_HINT_MASK_ORDER)
|
|
|
|
|
index_order[hint->type].set_bit (pos);
|
|
|
|
|
if (hint->clause & INDEX_HINT_MASK_GROUP)
|
|
|
|
|
index_group[hint->type].set_bit (pos);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* cannot mix USE INDEX and FORCE INDEX */
|
|
|
|
|
if ((!index_join[INDEX_HINT_FORCE].is_clear_all() ||
|
|
|
|
|
!index_order[INDEX_HINT_FORCE].is_clear_all() ||
|
|
|
|
|
!index_group[INDEX_HINT_FORCE].is_clear_all()) &&
|
|
|
|
|
(!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join ||
|
|
|
|
|
!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order ||
|
|
|
|
|
!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group))
|
|
|
|
|
{
|
|
|
|
|
my_error(ER_WRONG_USAGE, MYF(0), index_hint_type_name[INDEX_HINT_USE],
|
|
|
|
|
index_hint_type_name[INDEX_HINT_FORCE]);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* process FORCE INDEX as USE INDEX with a flag */
|
|
|
|
|
if (!index_join[INDEX_HINT_FORCE].is_clear_all() ||
|
|
|
|
|
!index_order[INDEX_HINT_FORCE].is_clear_all() ||
|
|
|
|
|
!index_group[INDEX_HINT_FORCE].is_clear_all())
|
|
|
|
|
{
|
2007-08-13 15:11:25 +02:00
|
|
|
tbl->force_index= TRUE;
|
2007-03-05 18:08:41 +01:00
|
|
|
index_join[INDEX_HINT_USE].merge(index_join[INDEX_HINT_FORCE]);
|
|
|
|
|
index_order[INDEX_HINT_USE].merge(index_order[INDEX_HINT_FORCE]);
|
|
|
|
|
index_group[INDEX_HINT_USE].merge(index_group[INDEX_HINT_FORCE]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* apply USE INDEX */
|
|
|
|
|
if (!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join)
|
2007-08-13 15:11:25 +02:00
|
|
|
tbl->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);
|
2007-03-05 18:08:41 +01:00
|
|
|
if (!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order)
|
2007-08-13 15:11:25 +02:00
|
|
|
tbl->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);
|
2007-03-05 18:08:41 +01:00
|
|
|
if (!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group)
|
2007-08-13 15:11:25 +02:00
|
|
|
tbl->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);
|
2007-03-05 18:08:41 +01:00
|
|
|
|
|
|
|
|
/* apply IGNORE INDEX */
|
2007-08-13 15:11:25 +02:00
|
|
|
tbl->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);
|
|
|
|
|
tbl->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);
|
|
|
|
|
tbl->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);
|
2007-03-05 18:08:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* make sure covering_keys don't include indexes disabled with a hint */
|
2007-08-13 15:11:25 +02:00
|
|
|
tbl->covering_keys.intersect(tbl->keys_in_use_for_query);
|
2007-03-05 18:08:41 +01:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
|
|
|
|
|
size_t max_row_length(TABLE *table, const uchar *data)
|
|
|
|
|
{
|
|
|
|
|
TABLE_SHARE *table_s= table->s;
|
|
|
|
|
size_t length= table_s->reclength + 2 * table_s->fields;
|
|
|
|
|
uint *const beg= table_s->blob_field;
|
|
|
|
|
uint *const end= beg + table_s->blob_fields;
|
|
|
|
|
|
|
|
|
|
for (uint *ptr= beg ; ptr != end ; ++ptr)
|
|
|
|
|
{
|
|
|
|
|
Field_blob* const blob= (Field_blob*) table->field[*ptr];
|
|
|
|
|
length+= blob->get_length((const uchar*)
|
|
|
|
|
(data + blob->offset(table->record[0]))) +
|
|
|
|
|
HA_KEY_BLOB_LENGTH;
|
|
|
|
|
}
|
|
|
|
|
return length;
|
|
|
|
|
}
|
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
|
** Instansiate templates
|
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
2005-06-22 11:08:28 +02:00
|
|
|
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
|
2000-07-31 21:29:14 +02:00
|
|
|
template class List<String>;
|
|
|
|
|
template class List_iterator<String>;
|
|
|
|
|
#endif
|