diff --git a/Docs/manual.texi b/Docs/manual.texi index 2516ce99f59..e302b9d4a98 100644 --- a/Docs/manual.texi +++ b/Docs/manual.texi @@ -3488,7 +3488,8 @@ select * from temporary_table, temporary_table as t2; @end example @item -@code{RENAME} doesn't work with @code{TEMPORARY} tables. +@code{RENAME} doesn't work with @code{TEMPORARY} tables or tables used in a +@code{MERGE} table. @item The optimiser may handle @code{DISTINCT} differently if you are using @@ -3584,6 +3585,7 @@ Minimum respective maximum possible @code{double} value. @item @code{LIMIT} on negative numbers are treated as big positive numbers. + @item If you use @code{ALTER TABLE} to first add an @code{UNIQUE} index to a table used in a @code{MERGE} table and then use @code{ALTER TABLE} to @@ -3731,6 +3733,9 @@ able to choose the right index when there is many to choose from. We should also extend the info interface to get the key distribution for each index, of @code{analyze} is run on all sub tables. @item +@code{RENAME TABLE} on a table used in an active @code{MERGE} table may +corrupt the table. +@item @code{SET SQL_DEFAULT_TABLE_TYPE=[MyISAM | INNODB | BDB | HEAP]}. @end itemize @@ -3800,8 +3805,6 @@ in microseconds. Add a configurable prompt to the @code{mysql} command line client, with options like database in use, time and date... @item -Add range checking to @code{MERGE} tables. -@item Link the @code{myisampack} code into the server. @item Port of MySQL to BeOS. @@ -6986,6 +6989,10 @@ Multithreaded clients should use @code{mysql_thread_init()} and If you want to recompile the perl DBD-MySQL module, you must get Msql-Mysql-modules version 1.2218 or newer, because the older DBD modules used the deprecated @code{drop_db()} call. +@item +@code{RAND(seed)} returns a different random number series in 4.0 than in +3.23; This was done to get @code{RAND(seed)} and @code{RAND(seed+1)} more +different. @end itemize @node Upgrading-from-3.22, Upgrading-from-3.21, Upgrading-from-3.23, Upgrade @@ -8334,12 +8341,14 @@ from usage by other threads. This has to do with the fact that on Windows, you can't delete a file that is in use by another threads. (In the future, we may find some way to work around this problem.) -@item @code{DROP TABLE} on a table that is in use by a @code{MERGE} table will not work -The @code{MERGE} handler does its table mapping hidden from MySQL. -Because Windows doesn't allow you to drop files that are open, you first -must flush all @code{MERGE} tables (with @code{FLUSH TABLES}) or drop the -@code{MERGE} table before dropping the table. We will fix this at the same -time we introduce @code{VIEW}s. +@item +@code{DROP TABLE} on a table that is in use by a @code{MERGE} table will +not work on windows becasue @code{MERGE} handler does the table mapping +hidden from the upper layer of MySQL. Because Windows doesn't allow you +to drop files that are open, you first must flush all @code{MERGE} +tables (with @code{FLUSH TABLES}) or drop the @code{MERGE} table before +dropping the table. We will fix this at the same time we introduce +@code{VIEW}s. @item @code{DATA DIRECTORY} and @code{INDEX DIRECTORY} directives in @code{CREATE TABLE} is ignored on windows, because windows doesn't support @@ -12283,7 +12292,7 @@ DROP TABLE tmp; @end example The above way to solve this query is in effect a @code{UNION} of two queries. - +@xref{UNION}. @node Calculating days, example-AUTO_INCREMENT, Searching on two keys, Examples @subsection Calculating visits per day @@ -15085,14 +15094,19 @@ You can specify wild cards in the hostname. For example, for any host in the @code{144.155.166} class C subnet. The simple form @code{user} is a synonym for @code{user@@"%"}. + +MySQL doesn't support wildcards in user names. Anonymous users are +defined by inserting entries with @code{User=''} into the +@code{mysql.user} table or creating an user with an empty name with the +@code{GRANT} command. + @strong{Note:} If you allow anonymous users to connect to the MySQL -server (which is the default), you should also add all local users as -@code{user@@localhost} because otherwise the anonymous user entry for the -local host in the @code{mysql.user} table will be used when the user tries to -log into the MySQL server from the local machine! Anonymous users -are defined by inserting entries with @code{User=''} into the -@code{mysql.user} table. You can verify if this applies to you by executing -this query: +server, you should also grant privileges to all local users as +@code{user@@localhost} because otherwise the anonymous user entry for +the local host in the @code{mysql.user} table will be used when the user +tries to log into the MySQL server from the local machine! + +You can verify if this applies to you by executing this query: @example mysql> SELECT Host,User FROM mysql.user WHERE User=''; @@ -24301,9 +24315,9 @@ option to @code{DELETE} may help. @xref{DELETE, , @code{DELETE}}. * MySQL indexes:: How MySQL Uses Indexes * Indexes:: Column Indexes * Multiple-column indexes:: Multiple-Column Indexes +* Open tables:: Why So Many Open tables? * Table cache:: How MySQL Opens and Closes Tables * Creating many tables:: Drawbacks to Creating Large Numbers of Tables in the Same Database -* Open tables:: Why So Many Open tables? @end menu @@ -24648,7 +24662,7 @@ created only from @code{VARCHAR} and @code{TEXT} columns. Indexing always happens over the entire column and partial indexing is not supported. See @ref{Fulltext Search} for details. -@node Multiple-column indexes, Table cache, Indexes, Optimising Database Structure +@node Multiple-column indexes, Open tables, Indexes, Optimising Database Structure @subsection Multiple-Column Indexes @cindex multi-column indexes @@ -24709,8 +24723,31 @@ For more information on the manner in which MySQL uses indexes to improve query performance, see @ref{MySQL indexes, , MySQL indexes}. +@node Open tables, Table cache, Multiple-column indexes, Optimising Database Structure +@subsection Why So Many Open tables? -@node Table cache, Creating many tables, Multiple-column indexes, Optimising Database Structure +@cindex tables, open +@cindex open tables + +When you run @code{mysqladmin status}, you'll see something like this: + +@example +Uptime: 426 Running threads: 1 Questions: 11082 Reloads: 1 Open tables: 12 +@end example + +This can be somewhat perplexing if you only have 6 tables. + +MySQL is multithreaded, so it may have many queries on the same table +simultaneously. To minimise the problem with two threads having +different states on the same file, the table is opened independently by +each concurrent thread. This takes some memory but will normaly increase +performance. Wth ISAM and MyISAM tables this also requires one extra file +descriptor for the data file. With these table types the index file +descriptor is shared between all threads. + +You can read more about this topic in the next section. @xref{Table cache}. + +@node Table cache, Creating many tables, Open tables, Optimising Database Structure @subsection How MySQL Opens and Closes Tables @findex table_cache @@ -24745,11 +24782,27 @@ in increase the number of file descriptors available for MySQL with the @code{--open-files-limit=#} startup option. @xref{Not enough file handles}. -The cache of open tables can grow to a maximum of @code{table_cache} -(default 64; this can be changed with the @code{-O table_cache=#} -option to @code{mysqld}). A table is never closed, except when the -cache is full and another thread tries to open a table or if you use -@code{mysqladmin refresh} or @code{mysqladmin flush-tables}. +The cache of open tables will be keept at a level of @code{table_cache} +entries (default 64; this can be changed with the @code{-O +table_cache=#} option to @code{mysqld}). Note that in MySQL may +temporarly open even more tables to be able to execute queries. + +A not used table is closed and removed from the table cache under the +following circumstances: + +@itemize @bullet +@item +When the cache is full and a thread tries to open a table that is not in +the cache. +@item +When the cache contains more than @code{table_cache} entires and +a thread is not anymore using a table. +@item +When someone executes @code{mysqladmin refresh} or +@code{mysqladmin flush-tables}. +@item +When someone executes 'FLUSH TABLES' +@end itemize When the table cache fills up, the server uses the following procedure to locate a cache entry to use: @@ -24780,15 +24833,16 @@ If you are opening a table with the @code{HANDLER table_name OPEN} statement, a dedicated table object is allocated for the thread. This table object is not shared by other threads an will not be closed until the thread calls @code{HANDLER table_name CLOSE} or the thread dies. -@xref{HANDLER}. +@xref{HANDLER}. When this happens, the table is put back in the table_cache +(if it isn't full). You can check if your table cache is too small by checking the mysqld -variable @code{opened_tables}. If this is quite big, even if you +variable @code{Opened_tables}. If this is quite big, even if you haven't done a lot of @code{FLUSH TABLES}, you should increase your table cache. @xref{SHOW STATUS}. -@node Creating many tables, Open tables, Table cache, Optimising Database Structure +@node Creating many tables, , Table cache, Optimising Database Structure @subsection Drawbacks to Creating Large Numbers of Tables in the Same Database @cindex tables, too many @@ -24800,28 +24854,6 @@ every table that has to be opened, another must be closed. You can reduce this overhead by making the table cache larger. -@node Open tables, , Creating many tables, Optimising Database Structure -@subsection Why So Many Open tables? - -@cindex tables, open -@cindex open tables - -When you run @code{mysqladmin status}, you'll see something like this: - -@example -Uptime: 426 Running threads: 1 Questions: 11082 Reloads: 1 Open tables: 12 -@end example - -This can be somewhat perplexing if you only have 6 tables. - -MySQL is multithreaded, so it may have many queries on the same -table simultaneously. To minimise the problem with two threads having -different states on the same file, the table is opened independently by -each concurrent thread. This takes some memory and one extra file -descriptor for the data file. The index file descriptor is shared -between all threads. - - @node Optimising the Server, Disk issues, Optimising Database Structure, MySQL Optimisation @section Optimising the MySQL Server @@ -29519,16 +29551,17 @@ Returns a random floating-point value in the range @code{0} to @code{1.0}. If an integer argument @code{N} is specified, it is used as the seed value: @example mysql> select RAND(); - -> 0.5925 + -> 0.9233482386203 mysql> select RAND(20); - -> 0.1811 + -> 0.15888261251047 mysql> select RAND(20); - -> 0.1811 + -> 0.15888261251047 mysql> select RAND(); - -> 0.2079 + -> 0.63553050033332 mysql> select RAND(); - -> 0.7888 + -> 0.70100469486881 @end example + You can't use a column with @code{RAND()} values in an @code{ORDER BY} clause, because @code{ORDER BY} would evaluate the column multiple times. In MySQL Version 3.23, you can, however, do: @@ -29540,6 +29573,10 @@ table1,table2 WHERE a=b AND c ALTER TABLE tbl_name TYPE = MYISAM; @end example +The embedded MySQL versions doesn't support ISAM tables. @node HEAP, InnoDB, ISAM, Table types @section HEAP Tables @@ -45921,6 +46001,14 @@ not yet 100% confident in this code. @appendixsubsec Changes in release 3.23.45 @itemize @bullet @item +Fix a bug which could cause InnoDB to complain if it cannot find free blocks +from the buffer cache during recovery. +@item +Fixed a bug in InnoDB insert buffer B-tree handling that could cause crashes. +@item +Fixed bug in @code{OPTIMIZE TABLE} that reset index cardinality if it +was up to date. +@item Fixed problem with @code{t1 LEFT_JOIN t2 ... WHERE t2.date_column IS NULL} when date_column was declared as @code{NOT NULL}. @item @@ -49798,7 +49886,7 @@ Fixed bug in record caches; for some queries, you could get Added user level lock functions @code{GET_LOCK(string,timeout)}, @code{RELEASE_LOCK(string)}. @item -Added @code{opened_tables} to @code{show status}. +Added @code{Opened_tables} to @code{show status}. @item Changed connect timeout to 3 seconds to make it somewhat harder for crackers to kill @code{mysqld} through telnet + TCP/IP. diff --git a/innobase/btr/btr0btr.c b/innobase/btr/btr0btr.c index 9cfd1806c5f..c71ef017aa8 100644 --- a/innobase/btr/btr0btr.c +++ b/innobase/btr/btr0btr.c @@ -21,7 +21,7 @@ Created 6/2/1994 Heikki Tuuri #include "lock0lock.h" #include "ibuf0ibuf.h" -/** +/* Node pointers ------------- Leaf pages of a B-tree contain the index records stored in the @@ -550,14 +550,15 @@ btr_page_get_father_for_rec( ut_ad(mtr_memo_contains(mtr, dict_tree_get_lock(tree), MTR_MEMO_X_LOCK)); - ut_ad(user_rec != page_get_supremum_rec(page)); - ut_ad(user_rec != page_get_infimum_rec(page)); + ut_a(user_rec != page_get_supremum_rec(page)); + ut_a(user_rec != page_get_infimum_rec(page)); ut_ad(dict_tree_get_page(tree) != buf_frame_get_page_no(page)); heap = mem_heap_create(100); - tuple = dict_tree_build_node_ptr(tree, user_rec, 0, heap); + tuple = dict_tree_build_node_ptr(tree, user_rec, 0, heap, + btr_page_get_level(page, mtr)); /* In the following, we choose just any index from the tree as the first parameter for btr_cur_search_to_nth_level. */ @@ -569,7 +570,7 @@ btr_page_get_father_for_rec( node_ptr = btr_cur_get_rec(&cursor); - ut_ad(btr_node_ptr_get_child_page_no(node_ptr) == + ut_a(btr_node_ptr_get_child_page_no(node_ptr) == buf_frame_get_page_no(page)); mem_heap_free(heap); @@ -949,8 +950,8 @@ btr_root_raise_and_insert( /* Build the node pointer (= node key and page address) for the child */ - node_ptr = dict_tree_build_node_ptr(tree, rec, new_page_no, heap); - + node_ptr = dict_tree_build_node_ptr(tree, rec, new_page_no, heap, + level); /* Reorganize the root to get free space */ btr_page_reorganize(root, mtr); @@ -1365,7 +1366,7 @@ btr_attach_half_pages( half */ node_ptr_upper = dict_tree_build_node_ptr(tree, split_rec, - upper_page_no, heap); + upper_page_no, heap, level); /* Insert it next to the pointer to the lower half. Note that this may generate recursion leading to a split on the higher level. */ @@ -2230,7 +2231,7 @@ btr_check_node_ptr( node_ptr_tuple = dict_tree_build_node_ptr( tree, page_rec_get_next(page_get_infimum_rec(page)), - 0, heap); + 0, heap, btr_page_get_level(page, mtr)); ut_a(cmp_dtuple_rec(node_ptr_tuple, node_ptr) == 0); @@ -2485,10 +2486,11 @@ loop: heap = mem_heap_create(256); node_ptr_tuple = dict_tree_build_node_ptr( - tree, + tree, page_rec_get_next( page_get_infimum_rec(page)), - 0, heap); + 0, heap, + btr_page_get_level(page, &mtr)); if (cmp_dtuple_rec(node_ptr_tuple, node_ptr) != 0) { diff --git a/innobase/btr/btr0cur.c b/innobase/btr/btr0cur.c index c553bcacf7f..7d80f6d5c64 100644 --- a/innobase/btr/btr0cur.c +++ b/innobase/btr/btr0cur.c @@ -2345,9 +2345,9 @@ btr_cur_pessimistic_delete( heap = mem_heap_create(256); node_ptr = dict_tree_build_node_ptr( - tree, page_rec_get_next(rec), - buf_frame_get_page_no(page), - heap); + tree, page_rec_get_next(rec), + buf_frame_get_page_no(page), + heap, btr_page_get_level(page, mtr)); btr_insert_on_non_leaf_level(tree, btr_page_get_level(page, mtr) + 1, diff --git a/innobase/buf/buf0flu.c b/innobase/buf/buf0flu.c index 4217a3ba99b..8184f10d6e9 100644 --- a/innobase/buf/buf0flu.c +++ b/innobase/buf/buf0flu.c @@ -138,15 +138,11 @@ buf_flush_ready_for_flush( return(TRUE); - } else if ((block->old || (UT_LIST_GET_LEN(buf_pool->LRU) - < BUF_LRU_OLD_MIN_LEN)) - && (block->buf_fix_count == 0)) { + } else if (block->buf_fix_count == 0) { /* If we are flushing the LRU list, to avoid deadlocks we require the block not to be bufferfixed, and hence - not latched. Since LRU flushed blocks are soon moved - to the free list, it is good to flush only old blocks - from the end of the LRU list. */ + not latched. */ return(TRUE); } @@ -560,6 +556,15 @@ buf_flush_try_neighbors( block = buf_page_hash_get(space, i); + if (block && flush_type == BUF_FLUSH_LRU && i != offset + && !block->old) { + + /* We avoid flushing 'non-old' blocks in an LRU flush, + because the flushed blocks are soon freed */ + + continue; + } + if (block && buf_flush_ready_for_flush(block, flush_type)) { mutex_exit(&(buf_pool->mutex)); diff --git a/innobase/dict/dict0dict.c b/innobase/dict/dict0dict.c index 0079ff08057..4b503a3dc49 100644 --- a/innobase/dict/dict0dict.c +++ b/innobase/dict/dict0dict.c @@ -2415,7 +2415,9 @@ dict_tree_build_node_ptr( dict_tree_t* tree, /* in: index tree */ rec_t* rec, /* in: record for which to build node pointer */ ulint page_no,/* in: page number to put in node pointer */ - mem_heap_t* heap) /* in: memory heap where pointer created */ + mem_heap_t* heap, /* in: memory heap where pointer created */ + ulint level) /* in: level of rec in tree: 0 means leaf + level */ { dtuple_t* tuple; dict_index_t* ind; @@ -2427,9 +2429,16 @@ dict_tree_build_node_ptr( if (tree->type & DICT_UNIVERSAL) { /* In a universal index tree, we take the whole record as - the node pointer */ + the node pointer if the reord is on the leaf level, + on non-leaf levels we remove the last field, which + contains the page number of the child page */ n_unique = rec_get_n_fields(rec); + + if (level > 0) { + ut_a(n_unique > 1); + n_unique--; + } } else { n_unique = dict_index_get_n_unique_in_tree(ind); } diff --git a/innobase/include/dict0dict.h b/innobase/include/dict0dict.h index a4ab4faa25c..ae313398c99 100644 --- a/innobase/include/dict0dict.h +++ b/innobase/include/dict0dict.h @@ -622,7 +622,9 @@ dict_tree_build_node_ptr( dict_tree_t* tree, /* in: index tree */ rec_t* rec, /* in: record for which to build node pointer */ ulint page_no,/* in: page number to put in node pointer */ - mem_heap_t* heap); /* in: memory heap where pointer created */ + mem_heap_t* heap, /* in: memory heap where pointer created */ + ulint level); /* in: level of rec in tree: 0 means leaf + level */ /************************************************************************** Copies an initial segment of a physical record, long enough to specify an index entry uniquely. */ diff --git a/mysql-test/r/create.result b/mysql-test/r/create.result index 5f14de18735..1bb3249bdc5 100644 --- a/mysql-test/r/create.result +++ b/mysql-test/r/create.result @@ -68,3 +68,12 @@ select * from t2 where b="world"; a B 3 world drop table t1,t2; +create table t1(x varchar(50) ); +create table t2 select x from t1 where 1=2; +describe t1; +Field Type Null Key Default Extra +x varchar(50) YES NULL +describe t2; +Field Type Null Key Default Extra +x char(50) YES NULL +drop table t1,t2; diff --git a/mysql-test/r/myisam.result b/mysql-test/r/myisam.result index dae87d88765..448c1b37592 100644 --- a/mysql-test/r/myisam.result +++ b/mysql-test/r/myisam.result @@ -31,3 +31,20 @@ check table t1; Table Op Msg_type Msg_text test.t1 check status OK drop table t1; +create table t1 (a int not null auto_increment, b int not null, primary key (a), index(b)); +insert into t1 (b) values (1),(2),(2),(2),(2); +optimize table t1; +Table Op Msg_type Msg_text +test.t1 optimize status OK +show index from t1; +Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Comment +t1 0 PRIMARY 1 a A 5 NULL NULL +t1 1 b 1 b A 1 NULL NULL +optimize table t1; +Table Op Msg_type Msg_text +test.t1 optimize status Table is already up to date +show index from t1; +Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Comment +t1 0 PRIMARY 1 a A 5 NULL NULL +t1 1 b 1 b A 1 NULL NULL +drop table t1; diff --git a/mysql-test/t/create.test b/mysql-test/t/create.test index 3eb4f35bdc2..57edb684744 100644 --- a/mysql-test/t/create.test +++ b/mysql-test/t/create.test @@ -65,3 +65,13 @@ create table t2 (key (b)) select * from t1; explain select * from t2 where b="world"; select * from t2 where b="world"; drop table t1,t2; + +# +# Test types after CREATE ... SELECT +# + +create table t1(x varchar(50) ); +create table t2 select x from t1 where 1=2; +describe t1; +describe t2; +drop table t1,t2; diff --git a/mysql-test/t/myisam.test b/mysql-test/t/myisam.test index 48a8b5d6c65..93462534b43 100644 --- a/mysql-test/t/myisam.test +++ b/mysql-test/t/myisam.test @@ -38,3 +38,15 @@ check table t1; repair table t1; check table t1; drop table t1; + +# +# Test bug: Two optimize in a row reset index cardinality +# + +create table t1 (a int not null auto_increment, b int not null, primary key (a), index(b)); +insert into t1 (b) values (1),(2),(2),(2),(2); +optimize table t1; +show index from t1; +optimize table t1; +show index from t1; +drop table t1; diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc index fafa4fe07d6..7a8585975cc 100644 --- a/sql/ha_myisam.cc +++ b/sql/ha_myisam.cc @@ -541,7 +541,7 @@ int ha_myisam::optimize(THD* thd, HA_CHECK_OPT *check_opt) int ha_myisam::repair(THD *thd, MI_CHECK ¶m, bool optimize) { int error=0; - uint extra_testflag=0; + uint local_testflag=param.testflag; bool optimize_done= !optimize, statistics_done=0; const char *old_proc_info=thd->proc_info; char fixed_name[FN_REFLEN]; @@ -570,19 +570,18 @@ int ha_myisam::repair(THD *thd, MI_CHECK ¶m, bool optimize) (!param.opt_rep_quick || !(share->state.changed & STATE_NOT_OPTIMIZED_KEYS)))) { - ulonglong key_map= ((param.testflag & T_CREATE_MISSING_KEYS) ? + ulonglong key_map= ((local_testflag & T_CREATE_MISSING_KEYS) ? ((ulonglong) 1L << share->base.keys)-1 : share->state.key_map); + uint testflag=param.testflag; if (mi_test_if_sort_rep(file,file->state->records,key_map,0) && - (param.testflag & T_REP_BY_SORT)) + (local_testflag & T_REP_BY_SORT)) { - uint testflag=param.testflag; - extra_testflag= T_STATISTICS; + local_testflag|= T_STATISTICS; param.testflag|= T_STATISTICS; // We get this for free thd->proc_info="Repair by sorting"; statistics_done=1; error = mi_repair_by_sort(¶m, file, fixed_name, param.opt_rep_quick); - param.testflag=testflag; } else { @@ -590,22 +589,28 @@ int ha_myisam::repair(THD *thd, MI_CHECK ¶m, bool optimize) param.testflag &= ~T_REP_BY_SORT; error= mi_repair(¶m, file, fixed_name, param.opt_rep_quick); } + param.testflag=testflag; + optimize_done=1; } if (!error) { - if ((param.testflag & T_SORT_INDEX) && + if ((local_testflag & T_SORT_INDEX) && (share->state.changed & STATE_NOT_SORTED_PAGES)) { optimize_done=1; thd->proc_info="Sorting index"; error=mi_sort_index(¶m,file,fixed_name); } - if (!statistics_done && (param.testflag & T_STATISTICS) && - (share->state.changed & STATE_NOT_ANALYZED)) + if (!statistics_done && (local_testflag & T_STATISTICS)) { - optimize_done=1; - thd->proc_info="Analyzing"; - error = chk_key(¶m, file); + if (share->state.changed & STATE_NOT_ANALYZED) + { + optimize_done=1; + thd->proc_info="Analyzing"; + error = chk_key(¶m, file); + } + else + local_testflag&= ~T_STATISTICS; // Don't update statistics } } thd->proc_info="Saving state"; @@ -620,10 +625,11 @@ int ha_myisam::repair(THD *thd, MI_CHECK ¶m, bool optimize) file->save_state=file->s->state.state; if (file->s->base.auto_key) update_auto_increment_key(¶m, file, 1); - error = update_state_info(¶m, file, - UPDATE_TIME | UPDATE_OPEN_COUNT | - ((param.testflag | extra_testflag) & - T_STATISTICS ? UPDATE_STAT : 0)); + if (optimize_done) + error = update_state_info(¶m, file, + UPDATE_TIME | UPDATE_OPEN_COUNT | + (local_testflag & + T_STATISTICS ? UPDATE_STAT : 0)); info(HA_STATUS_NO_LOCK | HA_STATUS_TIME | HA_STATUS_VARIABLE | HA_STATUS_CONST); if (rows != file->state->records && ! (param.testflag & T_VERY_SILENT)) diff --git a/sql/item_func.cc b/sql/item_func.cc index 1ca511be485..6657d860592 100644 --- a/sql/item_func.cc +++ b/sql/item_func.cc @@ -621,8 +621,8 @@ double Item_func_rand::val() { if (arg_count) { // Only use argument once in query - ulong tmp=((ulong) args[0]->val_int())+55555555L; - randominit(¤t_thd->rand,tmp,tmp/2); + ulong tmp=((ulong) args[0]->val_int()); + randominit(¤t_thd->rand,tmp*0x10001L+55555555L,tmp*0x10000001L); #ifdef DELETE_ITEMS delete args[0]; #endif