Below is the list of changes that have just been committed into a local
5.0 repository of jamppa. When jamppa does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html
ChangeSet@stripped, 2007-01-29 16:15:29+01:00, jani@stripped +18 -0
Merge bk://localhost:5559
into production.mysql.com:/usersnfs/jamppa/mysql-5.0
MERGE: 1.2341.4.23
client/mysqlbinlog.cc@stripped, 2007-01-29 16:15:21+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.130.1.2
client/mysqltest.c@stripped, 2007-01-29 16:15:21+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.268.1.2
include/my_pthread.h@stripped, 2007-01-29 16:15:21+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.92.1.2
include/mysql.h@stripped, 2007-01-29 16:15:21+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.166.1.2
libmysql/libmysql.c@stripped, 2007-01-29 16:15:22+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.253.1.1
mysql-test/t/mysqltest.test@stripped, 2007-01-29 16:15:22+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.49.1.1
mysys/default.c@stripped, 2007-01-29 16:15:22+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.83.1.3
server-tools/instance-manager/guardian.cc@stripped, 2007-01-29 16:15:22+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.25.1.2
sql/field.cc@stripped, 2007-01-29 16:15:22+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.335.1.3
sql/field.h@stripped, 2007-01-29 16:15:22+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.192.1.3
sql/item_sum.cc@stripped, 2007-01-29 16:15:22+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.192.1.2
sql/mysqld.cc@stripped, 2007-01-29 16:15:23+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.582.1.5
sql/net_serv.cc@stripped, 2007-01-29 16:15:23+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.93.1.2
sql/opt_range.cc@stripped, 2007-01-29 16:15:23+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.234.1.2
sql/sql_class.h@stripped, 2007-01-29 16:15:23+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.316.1.2
sql/sql_parse.cc@stripped, 2007-01-29 16:15:23+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.595.1.3
sql/sql_show.cc@stripped, 2007-01-29 16:15:24+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.333.1.2
tests/mysql_client_test.c@stripped, 2007-01-29 16:15:24+01:00, jani@stripped +0 -0
Auto merged
MERGE: 1.217.1.2
# This is a BitKeeper patch. What follows are the unified diffs for the
# set of deltas contained in the patch. The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User: jani
# Host: production.mysql.com
# Root: /usersnfs/jamppa/mysql-5.0/RESYNC
--- 1.95/include/my_pthread.h 2007-01-29 16:15:36 +01:00
+++ 1.96/include/my_pthread.h 2007-01-29 16:15:36 +01:00
@@ -351,14 +351,14 @@
we want to make sure that no such flags are set.
*/
#if defined(HAVE_SIGACTION) && !defined(my_sigset)
-#define my_sigset(A,B) do { struct sigaction s; sigset_t set; int rc; \
- DBUG_ASSERT((A) != 0); \
- sigemptyset(&set); \
- s.sa_handler = (B); \
- s.sa_mask = set; \
- s.sa_flags = 0; \
- rc= sigaction((A), &s, (struct sigaction *) NULL);\
- DBUG_ASSERT(rc == 0); \
+#define my_sigset(A,B) do { struct sigaction l_s; sigset_t l_set; int l_rc; \
+ DBUG_ASSERT((A) != 0); \
+ sigemptyset(&l_set); \
+ l_s.sa_handler = (B); \
+ l_s.sa_mask = l_set; \
+ l_s.sa_flags = 0; \
+ l_rc= sigaction((A), &l_s, (struct sigaction *) NULL);\
+ DBUG_ASSERT(l_rc == 0); \
} while (0)
#elif defined(HAVE_SIGSET) && !defined(my_sigset)
#define my_sigset(A,B) sigset((A),(B))
--- 1.168/include/mysql.h 2007-01-29 16:15:36 +01:00
+++ 1.169/include/mysql.h 2007-01-29 16:15:36 +01:00
@@ -87,6 +87,7 @@
#define IS_NUM(t) ((t) <= FIELD_TYPE_INT24 || (t) == FIELD_TYPE_YEAR || (t) == FIELD_TYPE_NEWDECIMAL)
#define IS_NUM_FIELD(f) ((f)->flags & NUM_FLAG)
#define INTERNAL_NUM_FIELD(f) (((f)->type <= FIELD_TYPE_INT24 && ((f)->type != FIELD_TYPE_TIMESTAMP || (f)->length == 14 || (f)->length == 8)) || (f)->type == FIELD_TYPE_YEAR)
+#define IS_LONGDATA(t) ((t) >= MYSQL_TYPE_TINY_BLOB && (t) <= MYSQL_TYPE_STRING)
typedef struct st_mysql_field {
@@ -783,7 +784,7 @@
unsigned long length);
int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt);
int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt);
-int STDCALL mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind,
+int STDCALL mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind_arg,
unsigned int column,
unsigned long offset);
int STDCALL mysql_stmt_store_result(MYSQL_STMT *stmt);
--- 1.254/libmysql/libmysql.c 2007-01-29 16:15:36 +01:00
+++ 1.255/libmysql/libmysql.c 2007-01-29 16:15:36 +01:00
@@ -2042,6 +2042,13 @@
DBUG_RETURN(1);
}
+ /*
+ Reset the last error in any case: that would clear the statement
+ if the previous prepare failed.
+ */
+ stmt->last_errno= 0;
+ stmt->last_error[0]= '\0';
+
if ((int) stmt->state > (int) MYSQL_STMT_INIT_DONE)
{
/* This is second prepare with another statement */
@@ -2055,23 +2062,24 @@
*/
stmt->bind_param_done= stmt->bind_result_done= FALSE;
stmt->param_count= stmt->field_count= 0;
- stmt->last_errno= 0;
- stmt->last_error[0]= '\0';
free_root(&stmt->mem_root, MYF(MY_KEEP_PREALLOC));
int4store(buff, stmt->stmt_id);
+
/*
+ Close statement in server
+
If there was a 'use' result from another statement, or from
mysql_use_result it won't be freed in mysql_stmt_free_result and
we should get 'Commands out of sync' here.
*/
+ stmt->state= MYSQL_STMT_INIT_DONE;
if (stmt_command(mysql, COM_STMT_CLOSE, buff, 4, stmt))
{
set_stmt_errmsg(stmt, mysql->net.last_error, mysql->net.last_errno,
mysql->net.sqlstate);
DBUG_RETURN(1);
}
- stmt->state= MYSQL_STMT_INIT_DONE;
}
if (stmt_command(mysql, COM_STMT_PREPARE, query, length, stmt))
--- 1.85/mysys/default.c 2007-01-29 16:15:36 +01:00
+++ 1.86/mysys/default.c 2007-01-29 16:15:36 +01:00
@@ -978,10 +978,11 @@
Everywhere else, this is:
1. /etc/
- 2. getenv(DEFAULT_HOME_ENV)
- 3. ""
- 4. "~/"
- 5. --sysconfdir=<path>
+ 2. /etc/mysql/
+ 3. getenv(DEFAULT_HOME_ENV)
+ 4. ""
+ 5. "~/"
+ 6. --sysconfdir=<path>
*/
@@ -1007,6 +1008,7 @@
*ptr++= env;
#endif
*ptr++= "/etc/";
+ *ptr++= "/etc/mysql/";
#endif
if ((env= getenv(STRINGIFY_ARG(DEFAULT_HOME_ENV))))
*ptr++= env;
--- 1.337/sql/field.cc 2007-01-29 16:15:36 +01:00
+++ 1.338/sql/field.cc 2007-01-29 16:15:36 +01:00
@@ -7826,6 +7826,16 @@
}
+Field *Field_enum::new_field(MEM_ROOT *root, struct st_table *new_table,
+ bool keep_type)
+{
+ Field_enum *res= (Field_enum*) Field::new_field(root, new_table, keep_type);
+ if (res)
+ res->typelib= copy_typelib(root, typelib);
+ return res;
+}
+
+
/*
set type.
This is a string which can have a collection of different values.
--- 1.194/sql/field.h 2007-01-29 16:15:36 +01:00
+++ 1.195/sql/field.h 2007-01-29 16:15:36 +01:00
@@ -1297,6 +1297,7 @@
{
flags|=ENUM_FLAG;
}
+ Field *new_field(MEM_ROOT *root, struct st_table *new_table, bool keep_type);
enum_field_types type() const { return FIELD_TYPE_STRING; }
enum Item_result cmp_type () const { return INT_RESULT; }
enum Item_result cast_to_int_type () const { return INT_RESULT; }
--- 1.194/sql/item_sum.cc 2007-01-29 16:15:36 +01:00
+++ 1.195/sql/item_sum.cc 2007-01-29 16:15:36 +01:00
@@ -1113,7 +1113,7 @@
{
/*
We must store both value and counter in the temporary table in one field.
- The easyest way is to do this is to store both value in a string
+ The easiest way is to do this is to store both value in a string
and unpack on access.
*/
return new Field_string(((hybrid_type == DECIMAL_RESULT) ?
@@ -1187,8 +1187,9 @@
double Item_sum_std::val_real()
{
DBUG_ASSERT(fixed == 1);
- double tmp= Item_sum_variance::val_real();
- return tmp <= 0.0 ? 0.0 : sqrt(tmp);
+ double nr= Item_sum_variance::val_real();
+ DBUG_ASSERT(nr >= 0.0);
+ return sqrt(nr);
}
Item *Item_sum_std::copy_or_same(THD* thd)
@@ -1202,40 +1203,77 @@
*/
-Item_sum_variance::Item_sum_variance(THD *thd, Item_sum_variance *item):
- Item_sum_num(thd, item), hybrid_type(item->hybrid_type),
- cur_dec(item->cur_dec), count(item->count), sample(item->sample),
- prec_increment(item->prec_increment)
+/**
+ Variance implementation for floating-point implementations, without
+ catastrophic cancellation, from Knuth's _TAoCP_, 3rd ed, volume 2, pg232.
+ This alters the value at m, s, and increments count.
+*/
+
+/*
+ These two functions are used by the Item_sum_variance and the
+ Item_variance_field classes, which are unrelated, and each need to calculate
+ variance. The difference between the two classes is that the first is used
+ for a mundane SELECT, while the latter is used in a GROUPing SELECT.
+*/
+static void variance_fp_recurrence_next(double *m, double *s, ulonglong *count, double nr)
{
- if (hybrid_type == DECIMAL_RESULT)
+ *count += 1;
+
+ if (*count == 1)
{
- memcpy(dec_sum, item->dec_sum, sizeof(item->dec_sum));
- memcpy(dec_sqr, item->dec_sqr, sizeof(item->dec_sqr));
- for (int i=0; i<2; i++)
- {
- dec_sum[i].fix_buffer_pointer();
- dec_sqr[i].fix_buffer_pointer();
- }
+ *m= nr;
+ *s= 0;
}
else
{
- sum= item->sum;
- sum_sqr= item->sum_sqr;
+ double m_kminusone= *m;
+ *m= m_kminusone + (nr - m_kminusone) / (double) *count;
+ *s= *s + (nr - m_kminusone) * (nr - *m);
}
}
+static double variance_fp_recurrence_result(double s, ulonglong count, bool is_sample_variance)
+{
+ if (count == 1)
+ return 0.0;
+
+ if (is_sample_variance)
+ return s / (count - 1);
+
+ /* else, is a population variance */
+ return s / count;
+}
+
+
+Item_sum_variance::Item_sum_variance(THD *thd, Item_sum_variance *item):
+ Item_sum_num(thd, item), hybrid_type(item->hybrid_type),
+ count(item->count), sample(item->sample),
+ prec_increment(item->prec_increment)
+{
+ recurrence_m= item->recurrence_m;
+ recurrence_s= item->recurrence_s;
+}
+
+
void Item_sum_variance::fix_length_and_dec()
{
DBUG_ENTER("Item_sum_variance::fix_length_and_dec");
maybe_null= null_value= 1;
prec_increment= current_thd->variables.div_precincrement;
+
+ /*
+ According to the SQL2003 standard (Part 2, Foundations; sec 10.9,
+ aggregate function; paragraph 7h of Syntax Rules), "the declared
+ type of the result is an implementation-defined aproximate numeric
+ type.
+ */
+ hybrid_type= REAL_RESULT;
+
switch (args[0]->result_type()) {
case REAL_RESULT:
case STRING_RESULT:
decimals= min(args[0]->decimals + 4, NOT_FIXED_DEC);
- hybrid_type= REAL_RESULT;
- sum= 0.0;
break;
case INT_RESULT:
case DECIMAL_RESULT:
@@ -1244,37 +1282,14 @@
decimals= min(args[0]->decimals + prec_increment, DECIMAL_MAX_SCALE);
max_length= my_decimal_precision_to_length(precision, decimals,
unsigned_flag);
- cur_dec= 0;
- hybrid_type= DECIMAL_RESULT;
- my_decimal_set_zero(dec_sum);
- my_decimal_set_zero(dec_sqr);
- /*
- The maxium value to usable for variance is DECIMAL_MAX_LENGTH/2
- becasue we need to be able to calculate in dec_bin_size1
- column_value * column_value
- */
- f_scale0= args[0]->decimals;
- f_precision0= min(args[0]->decimal_precision() + DECIMAL_LONGLONG_DIGITS,
- DECIMAL_MAX_PRECISION);
- f_scale1= min(args[0]->decimals * 2, DECIMAL_MAX_SCALE);
- f_precision1= min(args[0]->decimal_precision()*2 + DECIMAL_LONGLONG_DIGITS,
- DECIMAL_MAX_PRECISION);
- dec_bin_size0= my_decimal_get_binary_size(f_precision0, f_scale0);
- dec_bin_size1= my_decimal_get_binary_size(f_precision1, f_scale1);
break;
}
case ROW_RESULT:
default:
DBUG_ASSERT(0);
}
- DBUG_PRINT("info", ("Type: %s (%d, %d)",
- (hybrid_type == REAL_RESULT ? "REAL_RESULT" :
- hybrid_type == DECIMAL_RESULT ? "DECIMAL_RESULT" :
- hybrid_type == INT_RESULT ? "INT_RESULT" :
- "--ILLEGAL!!!--"),
- max_length,
- (int)decimals));
+ DBUG_PRINT("info", ("Type: REAL_RESULT (%d, %d)", max_length, (int)decimals));
DBUG_VOID_RETURN;
}
@@ -1285,6 +1300,11 @@
}
+/**
+ Create a new field to match the type of value we're expected to yield.
+ If we're grouping, then we need some space to serialize variables into, to
+ pass around.
+*/
Field *Item_sum_variance::create_tmp_field(bool group, TABLE *table,
uint convert_blob_len)
{
@@ -1292,13 +1312,10 @@
{
/*
We must store both value and counter in the temporary table in one field.
- The easyest way is to do this is to store both value in a string
+ The easiest way is to do this is to store both value in a string
and unpack on access.
*/
- return new Field_string(((hybrid_type == DECIMAL_RESULT) ?
- dec_bin_size0 + dec_bin_size1 :
- sizeof(double)*2) + sizeof(longlong),
- 0, name, table, &my_charset_bin);
+ return new Field_string(sizeof(double)*2 + sizeof(longlong), 0, name, table, &my_charset_bin);
}
return new Field_double(max_length, maybe_null,name,table,decimals);
}
@@ -1306,90 +1323,51 @@
void Item_sum_variance::clear()
{
- if (hybrid_type == DECIMAL_RESULT)
- {
- my_decimal_set_zero(dec_sum);
- my_decimal_set_zero(dec_sqr);
- cur_dec= 0;
- }
- else
- sum=sum_sqr=0.0;
- count=0;
+ count= 0;
}
bool Item_sum_variance::add()
{
- if (hybrid_type == DECIMAL_RESULT)
- {
- my_decimal dec_buf, *dec= args[0]->val_decimal(&dec_buf);
- my_decimal sqr_buf;
- if (!args[0]->null_value)
- {
- count++;
- int next_dec= cur_dec ^ 1;
- my_decimal_mul(E_DEC_FATAL_ERROR, &sqr_buf, dec, dec);
- my_decimal_add(E_DEC_FATAL_ERROR, dec_sqr+next_dec,
- dec_sqr+cur_dec, &sqr_buf);
- my_decimal_add(E_DEC_FATAL_ERROR, dec_sum+next_dec,
- dec_sum+cur_dec, dec);
- cur_dec= next_dec;
- }
- }
- else
- {
- double nr= args[0]->val_real();
- if (!args[0]->null_value)
- {
- sum+=nr;
- sum_sqr+=nr*nr;
- count++;
- }
- }
+ /*
+ Why use a temporary variable? We don't know if it is null until we
+ evaluate it, which has the side-effect of setting null_value .
+ */
+ double nr= args[0]->val_real();
+
+ if (!args[0]->null_value)
+ variance_fp_recurrence_next(&recurrence_m, &recurrence_s, &count, nr);
return 0;
}
double Item_sum_variance::val_real()
{
DBUG_ASSERT(fixed == 1);
- if (hybrid_type == DECIMAL_RESULT)
- return val_real_from_decimal();
+ /*
+ 'sample' is a 1/0 boolean value. If it is 1/true, id est this is a sample
+ variance call, then we should set nullness when the count of the items
+ is one or zero. If it's zero, i.e. a population variance, then we only
+ set nullness when the count is zero.
+
+ Another way to read it is that 'sample' is the numerical threshhold, at and
+ below which a 'count' number of items is called NULL.
+ */
+ DBUG_ASSERT((sample == 0) || (sample == 1));
if (count <= sample)
{
null_value=1;
return 0.0;
}
+
null_value=0;
- /* Avoid problems when the precision isn't good enough */
- double tmp=ulonglong2double(count);
- double tmp2= (sum_sqr - sum*sum/tmp)/(tmp - (double)sample);
- return tmp2 <= 0.0 ? 0.0 : tmp2;
+ return variance_fp_recurrence_result(recurrence_s, count, sample);
}
my_decimal *Item_sum_variance::val_decimal(my_decimal *dec_buf)
{
- my_decimal count_buf, count1_buf, sum_sqr_buf;
- DBUG_ASSERT(fixed ==1 );
- if (hybrid_type == REAL_RESULT)
- return val_decimal_from_real(dec_buf);
-
- if (count <= sample)
- {
- null_value= 1;
- return 0;
- }
- null_value= 0;
- int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &count_buf);
- int2my_decimal(E_DEC_FATAL_ERROR, count-sample, 0, &count1_buf);
- my_decimal_mul(E_DEC_FATAL_ERROR, &sum_sqr_buf,
- dec_sum+cur_dec, dec_sum+cur_dec);
- my_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
- &sum_sqr_buf, &count_buf, prec_increment);
- my_decimal_sub(E_DEC_FATAL_ERROR, &sum_sqr_buf, dec_sqr+cur_dec, dec_buf);
- my_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
- &sum_sqr_buf, &count1_buf, prec_increment);
- return dec_buf;
+ DBUG_ASSERT(fixed == 1);
+ return val_decimal_from_real(dec_buf);
}
@@ -1398,89 +1376,44 @@
double nr;
char *res= result_field->ptr;
- if (hybrid_type == DECIMAL_RESULT)
- {
- my_decimal value, *arg_dec, *arg2_dec;
- longlong tmp;
-
- arg_dec= args[0]->val_decimal(&value);
- if (args[0]->null_value)
- {
- arg_dec= arg2_dec= &decimal_zero;
- tmp= 0;
- }
- else
- {
- my_decimal_mul(E_DEC_FATAL_ERROR, dec_sum, arg_dec, arg_dec);
- arg2_dec= dec_sum;
- tmp= 1;
- }
- my_decimal2binary(E_DEC_FATAL_ERROR, arg_dec,
- res, f_precision0, f_scale0);
- my_decimal2binary(E_DEC_FATAL_ERROR, arg2_dec,
- res+dec_bin_size0, f_precision1, f_scale1);
- res+= dec_bin_size0 + dec_bin_size1;
- int8store(res,tmp);
- return;
- }
- nr= args[0]->val_real();
+ nr= args[0]->val_real(); /* sets null_value as side-effect */
if (args[0]->null_value)
bzero(res,sizeof(double)*2+sizeof(longlong));
else
{
- longlong tmp;
- float8store(res,nr);
- nr*=nr;
- float8store(res+sizeof(double),nr);
- tmp= 1;
- int8store(res+sizeof(double)*2,tmp);
+ /* Serialize format is (double)m, (double)s, (longlong)count */
+ ulonglong tmp_count;
+ double tmp_s;
+ float8store(res, nr); /* recurrence variable m */
+ tmp_s= 0.0;
+ float8store(res + sizeof(double), tmp_s);
+ tmp_count= 1;
+ int8store(res + sizeof(double)*2, tmp_count);
}
}
void Item_sum_variance::update_field()
{
- longlong field_count;
+ ulonglong field_count;
char *res=result_field->ptr;
- if (hybrid_type == DECIMAL_RESULT)
- {
- my_decimal value, *arg_val= args[0]->val_decimal(&value);
- if (!args[0]->null_value)
- {
- binary2my_decimal(E_DEC_FATAL_ERROR, res,
- dec_sum+1, f_precision0, f_scale0);
- binary2my_decimal(E_DEC_FATAL_ERROR, res+dec_bin_size0,
- dec_sqr+1, f_precision1, f_scale1);
- field_count= sint8korr(res + (dec_bin_size0 + dec_bin_size1));
- my_decimal_add(E_DEC_FATAL_ERROR, dec_sum, arg_val, dec_sum+1);
- my_decimal_mul(E_DEC_FATAL_ERROR, dec_sum+1, arg_val, arg_val);
- my_decimal_add(E_DEC_FATAL_ERROR, dec_sqr, dec_sqr+1, dec_sum+1);
- field_count++;
- my_decimal2binary(E_DEC_FATAL_ERROR, dec_sum,
- res, f_precision0, f_scale0);
- my_decimal2binary(E_DEC_FATAL_ERROR, dec_sqr,
- res+dec_bin_size0, f_precision1, f_scale1);
- res+= dec_bin_size0 + dec_bin_size1;
- int8store(res, field_count);
- }
+
+ double nr= args[0]->val_real(); /* sets null_value as side-effect */
+
+ if (args[0]->null_value)
return;
- }
- double nr,old_nr,old_sqr;
- float8get(old_nr, res);
- float8get(old_sqr, res+sizeof(double));
+ /* Serialize format is (double)m, (double)s, (longlong)count */
+ double field_recurrence_m, field_recurrence_s;
+ float8get(field_recurrence_m, res);
+ float8get(field_recurrence_s, res + sizeof(double));
field_count=sint8korr(res+sizeof(double)*2);
- nr= args[0]->val_real();
- if (!args[0]->null_value)
- {
- old_nr+=nr;
- old_sqr+=nr*nr;
- field_count++;
- }
- float8store(res,old_nr);
- float8store(res+sizeof(double),old_sqr);
+ variance_fp_recurrence_next(&field_recurrence_m, &field_recurrence_s, &field_count, nr);
+
+ float8store(res, field_recurrence_m);
+ float8store(res + sizeof(double), field_recurrence_s);
res+= sizeof(double)*2;
int8store(res,field_count);
}
@@ -2310,25 +2243,9 @@
{
double nr;
// fix_fields() never calls for this Item
- if (hybrid_type == REAL_RESULT)
- {
- /*
- We can't call Item_variance_field::val_real() on a DECIMAL_RESULT
- as this would call Item_std_field::val_decimal() and we would
- calculate sqrt() twice
- */
- nr= Item_variance_field::val_real();
- }
- else
- {
- my_decimal dec_buf,*dec;
- dec= Item_variance_field::val_decimal(&dec_buf);
- if (!dec)
- nr= 0.0; // NULL; Return 0.0
- else
- my_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
- }
- return nr <= 0.0 ? 0.0 : sqrt(nr);
+ nr= Item_variance_field::val_real();
+ DBUG_ASSERT(nr >= 0.0);
+ return sqrt(nr);
}
@@ -2342,11 +2259,13 @@
double nr;
if (hybrid_type == REAL_RESULT)
return val_decimal_from_real(dec_buf);
+
dec= Item_variance_field::val_decimal(dec_buf);
if (!dec)
return 0;
my_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
- nr= nr <= 0.0 ? 0.0 : sqrt(nr);
+ DBUG_ASSERT(nr >= 0.0);
+ nr= sqrt(nr);
double2my_decimal(E_DEC_FATAL_ERROR, nr, &tmp_dec);
my_decimal_round(E_DEC_FATAL_ERROR, &tmp_dec, decimals, FALSE, dec_buf);
return dec_buf;
@@ -2381,52 +2300,15 @@
if (hybrid_type == DECIMAL_RESULT)
return val_real_from_decimal();
- double sum,sum_sqr;
- longlong count;
- float8get(sum,field->ptr);
- float8get(sum_sqr,(field->ptr+sizeof(double)));
+ double recurrence_s;
+ ulonglong count;
+ float8get(recurrence_s, (field->ptr + sizeof(double)));
count=sint8korr(field->ptr+sizeof(double)*2);
if ((null_value= (count <= sample)))
return 0.0;
- double tmp= (double) count;
- double tmp2= (sum_sqr - sum*sum/tmp)/(tmp - (double)sample);
- return tmp2 <= 0.0 ? 0.0 : tmp2;
-}
-
-
-String *Item_variance_field::val_str(String *str)
-{
- if (hybrid_type == DECIMAL_RESULT)
- return val_string_from_decimal(str);
- return val_string_from_real(str);
-}
-
-
-my_decimal *Item_variance_field::val_decimal(my_decimal *dec_buf)
-{
- // fix_fields() never calls for this Item
- if (hybrid_type == REAL_RESULT)
- return val_decimal_from_real(dec_buf);
-
- longlong count= sint8korr(field->ptr+dec_bin_size0+dec_bin_size1);
- if ((null_value= (count <= sample)))
- return 0;
-
- my_decimal dec_count, dec1_count, dec_sum, dec_sqr, tmp;
- int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &dec_count);
- int2my_decimal(E_DEC_FATAL_ERROR, count-sample, 0, &dec1_count);
- binary2my_decimal(E_DEC_FATAL_ERROR, field->ptr,
- &dec_sum, f_precision0, f_scale0);
- binary2my_decimal(E_DEC_FATAL_ERROR, field->ptr+dec_bin_size0,
- &dec_sqr, f_precision1, f_scale1);
- my_decimal_mul(E_DEC_FATAL_ERROR, &tmp, &dec_sum, &dec_sum);
- my_decimal_div(E_DEC_FATAL_ERROR, dec_buf, &tmp, &dec_count, prec_increment);
- my_decimal_sub(E_DEC_FATAL_ERROR, &dec_sum, &dec_sqr, dec_buf);
- my_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
- &dec_sum, &dec1_count, prec_increment);
- return dec_buf;
+ return variance_fp_recurrence_result(recurrence_s, count, sample);
}
--- 1.132/client/mysqlbinlog.cc 2007-01-29 16:15:36 +01:00
+++ 1.133/client/mysqlbinlog.cc 2007-01-29 16:15:36 +01:00
@@ -91,13 +91,12 @@
This is because the event will be created (alloced) in read_log_event()
(which returns a pointer) in check_header().
*/
-Format_description_log_event* description_event;
+Format_description_log_event* glob_description_event;
static int dump_local_log_entries(const char* logname);
static int dump_remote_log_entries(const char* logname);
static int dump_log_entries(const char* logname);
-static int dump_remote_file(NET* net, const char* fname);
-static void die(const char* fmt, ...);
+static void die(const char* fmt, ...) __attribute__ ((__noreturn__));
static MYSQL* safe_connect();
@@ -558,7 +557,7 @@
ce->print(result_file, print_event_info, TRUE);
// If this binlog is not 3.23 ; why this test??
- if (description_event->binlog_version >= 3)
+ if (glob_description_event->binlog_version >= 3)
{
if (load_processor.process(ce))
break; // Error
@@ -593,9 +592,9 @@
break;
}
case FORMAT_DESCRIPTION_EVENT:
- delete description_event;
- description_event= (Format_description_log_event*) ev;
- print_event_info->common_header_len= description_event->common_header_len;
+ delete glob_description_event;
+ glob_description_event= (Format_description_log_event*) ev;
+ print_event_info->common_header_len= glob_description_event->common_header_len;
ev->print(result_file, print_event_info);
/*
We don't want this event to be deleted now, so let's hide it (I
@@ -801,7 +800,7 @@
static void print_version()
{
- printf("%s Ver 3.1 for %s at %s\n", my_progname, SYSTEM_TYPE, MACHINE_TYPE);
+ printf("%s Ver 3.2 for %s at %s\n", my_progname, SYSTEM_TYPE, MACHINE_TYPE);
NETWARE_SET_SCREEN_MODE(1);
}
@@ -958,7 +957,7 @@
This is not as smart as check_header() (used for local log); it will not work
for a binlog which mixes format. TODO: fix this.
*/
-static int check_master_version(MYSQL* mysql,
+static int check_master_version(MYSQL *mysql_arg,
Format_description_log_event
**description_event)
{
@@ -966,26 +965,31 @@
MYSQL_ROW row;
const char* version;
- if (mysql_query(mysql, "SELECT VERSION()") ||
- !(res = mysql_store_result(mysql)))
+ if (mysql_query(mysql_arg, "SELECT VERSION()") ||
+ !(res = mysql_store_result(mysql_arg)))
{
+ /* purecov: begin inspected */
char errmsg[256];
- strmake(errmsg, mysql_error(mysql), sizeof(errmsg)-1);
- mysql_close(mysql);
+ strmake(errmsg, mysql_error(mysql_arg), sizeof(errmsg)-1);
+ mysql_close(mysql_arg);
die("Error checking master version: %s", errmsg);
+ /* purecov: end */
}
if (!(row = mysql_fetch_row(res)))
{
+ /* purecov: begin inspected */
mysql_free_result(res);
mysql_close(mysql);
die("Master returned no rows for SELECT VERSION()");
- return 1;
+ /* purecov: end */
}
if (!(version = row[0]))
{
+ /* purecov: begin inspected */
mysql_free_result(res);
- mysql_close(mysql);
+ mysql_close(mysql_arg);
die("Master reported NULL for the version");
+ /* purecov: end */
}
switch (*version) {
@@ -1004,11 +1008,11 @@
*description_event= new Format_description_log_event(3);
break;
default:
- sql_print_error("Master reported unrecognized MySQL version '%s'",
- version);
+ /* purecov: begin inspected */
mysql_free_result(res);
- mysql_close(mysql);
- return 1;
+ mysql_close(mysql_arg);
+ die("Master reported unrecognized MySQL version '%s'", version);
+ /* purecov: end */
}
mysql_free_result(res);
return 0;
@@ -1036,12 +1040,12 @@
mysql= safe_connect();
net= &mysql->net;
- if (check_master_version(mysql, &description_event))
+ if (check_master_version(mysql, &glob_description_event))
{
fprintf(stderr, "Could not find server version");
DBUG_RETURN(1);
}
- if (!description_event || !description_event->is_valid())
+ if (!glob_description_event || !glob_description_event->is_valid())
{
fprintf(stderr, "Invalid Format_description log event; \
could be out of memory");
@@ -1091,7 +1095,7 @@
len, net->read_pos[5]));
if (!(ev= Log_event::read_log_event((const char*) net->read_pos + 1 ,
len - 1, &error_msg,
- description_event)))
+ glob_description_event)))
{
fprintf(stderr, "Could not construct log event object\n");
error= 1;
@@ -1099,7 +1103,7 @@
}
Log_event_type type= ev->get_type_code();
- if (description_event->binlog_version >= 3 ||
+ if (glob_description_event->binlog_version >= 3 ||
(type != LOAD_EVENT && type != CREATE_FILE_EVENT))
{
/*
@@ -1305,7 +1309,7 @@
my_close(fd, MYF(MY_WME));
return 1;
}
- check_header(file, &description_event);
+ check_header(file, &glob_description_event);
}
else // reading from stdin;
{
@@ -1331,7 +1335,7 @@
if (init_io_cache(file, fileno(stdin), 0, READ_CACHE, (my_off_t) 0,
0, MYF(MY_WME | MY_NABP | MY_DONT_CHECK_FILESIZE)))
return 1;
- check_header(file, &description_event);
+ check_header(file, &glob_description_event);
if (start_position)
{
/* skip 'start_position' characters from stdin */
@@ -1349,7 +1353,7 @@
}
}
- if (!description_event || !description_event->is_valid())
+ if (!glob_description_event || !glob_description_event->is_valid())
die("Invalid Format_description log event; could be out of memory");
if (!start_position && my_b_read(file, tmp_buff, BIN_LOG_HEADER_SIZE))
@@ -1362,14 +1366,14 @@
char llbuff[21];
my_off_t old_off = my_b_tell(file);
- Log_event* ev = Log_event::read_log_event(file, description_event);
+ Log_event* ev = Log_event::read_log_event(file, glob_description_event);
if (!ev)
{
/*
if binlog wasn't closed properly ("in use" flag is set) don't complain
about a corruption, but treat it as EOF and move to the next binlog.
*/
- if (description_event->flags & LOG_EVENT_BINLOG_IN_USE_F)
+ if (glob_description_event->flags & LOG_EVENT_BINLOG_IN_USE_F)
file->error= 0;
else if (file->error)
{
@@ -1394,7 +1398,7 @@
if (fd >= 0)
my_close(fd, MYF(MY_WME));
end_io_cache(file);
- delete description_event;
+ delete glob_description_event;
return error;
}
--- 1.585/sql/mysqld.cc 2007-01-29 16:15:37 +01:00
+++ 1.586/sql/mysqld.cc 2007-01-29 16:15:37 +01:00
@@ -3371,8 +3371,10 @@
int main(int argc, char **argv)
#endif
{
- DEBUGGER_OFF;
MY_INIT(argv[0]); // init my_sys library & pthreads
+ /* ^^^ Nothing should be before this line! */
+
+ DEBUGGER_OFF;
#ifdef _CUSTOMSTARTUPCONFIG_
if (_cust_check_startup())
--- 1.95/sql/net_serv.cc 2007-01-29 16:15:37 +01:00
+++ 1.96/sql/net_serv.cc 2007-01-29 16:15:37 +01:00
@@ -221,6 +221,8 @@
-1 Don't know if data is ready or not
*/
+#if !defined(EMBEDDED_LIBRARY)
+
static int net_data_is_ready(my_socket sd)
{
#ifdef HAVE_POLL
@@ -255,9 +257,10 @@
return 0;
else
return test(res ? FD_ISSET(sd, &sfds) : 0);
-#endif
+#endif /* HAVE_POLL */
}
+#endif /* EMBEDDED_LIBRARY */
/*
Remove unwanted characters from connection
@@ -282,8 +285,11 @@
void net_clear(NET *net)
{
+#if !defined(EMBEDDED_LIBRARY)
int count, ready;
+#endif
DBUG_ENTER("net_clear");
+
#if !defined(EMBEDDED_LIBRARY)
while((ready= net_data_is_ready(net->vio->sd)) > 0)
{
--- 1.237/sql/opt_range.cc 2007-01-29 16:15:37 +01:00
+++ 1.238/sql/opt_range.cc 2007-01-29 16:15:37 +01:00
@@ -496,9 +496,6 @@
double read_time);
static
TRP_GROUP_MIN_MAX *get_best_group_min_max(PARAM *param, SEL_TREE *tree);
-static int get_index_merge_params(PARAM *param, key_map& needed_reg,
- SEL_IMERGE *imerge, double *read_time,
- ha_rows* imerge_rows);
static double get_index_only_read_time(const PARAM* param, ha_rows records,
int keynr);
@@ -508,7 +505,6 @@
static void print_ror_scans_arr(TABLE *table, const char *msg,
struct st_ror_scan_info **start,
struct st_ror_scan_info **end);
-static void print_rowid(byte* val, int len);
static void print_quick(QUICK_SELECT_I *quick, const key_map *needed_reg);
#endif
@@ -820,7 +816,7 @@
QUICK_RANGE_SELECT::QUICK_RANGE_SELECT(THD *thd, TABLE *table, uint key_nr,
bool no_alloc, MEM_ROOT *parent_alloc)
- :dont_free(0),error(0),free_file(0),in_range(0),cur_range(NULL),range(0)
+ :dont_free(0),error(0),free_file(0),in_range(0),cur_range(NULL),last_range(0)
{
sorted= 0;
index= key_nr;
@@ -1245,13 +1241,12 @@
int QUICK_ROR_UNION_SELECT::reset()
{
- QUICK_SELECT_I* quick;
+ QUICK_SELECT_I *quick;
int error;
DBUG_ENTER("QUICK_ROR_UNION_SELECT::reset");
have_prev_rowid= FALSE;
if (!scans_inited)
{
- QUICK_SELECT_I *quick;
List_iterator_fast<QUICK_SELECT_I> it(quick_selects);
while ((quick= it++))
{
@@ -6589,7 +6584,7 @@
byte *mrange_buff;
DBUG_ENTER("QUICK_RANGE_SELECT::reset");
next=0;
- range= NULL;
+ last_range= NULL;
in_range= FALSE;
cur_range= (QUICK_RANGE**) ranges.buffer;
@@ -6707,23 +6702,23 @@
{
start_key= &mrange_slot->start_key;
end_key= &mrange_slot->end_key;
- range= *(cur_range++);
+ last_range= *(cur_range++);
- start_key->key= (const byte*) range->min_key;
- start_key->length= range->min_length;
- start_key->flag= ((range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
- (range->flag & EQ_RANGE) ?
+ start_key->key= (const byte*) last_range->min_key;
+ start_key->length= last_range->min_length;
+ start_key->flag= ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
+ (last_range->flag & EQ_RANGE) ?
HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT);
- end_key->key= (const byte*) range->max_key;
- end_key->length= range->max_length;
+ end_key->key= (const byte*) last_range->max_key;
+ end_key->length= last_range->max_length;
/*
We use HA_READ_AFTER_KEY here because if we are reading on a key
prefix. We want to find all keys with this prefix.
*/
- end_key->flag= (range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY :
+ end_key->flag= (last_range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY :
HA_READ_AFTER_KEY);
- mrange_slot->range_flag= range->flag;
+ mrange_slot->range_flag= last_range->flag;
}
result= file->read_multi_range_first(&mrange, multi_range, count,
@@ -6773,7 +6768,7 @@
{
int result;
key_range start_key, end_key;
- if (range)
+ if (last_range)
{
/* Read the next record in the same range with prefix after cur_prefix. */
DBUG_ASSERT(cur_prefix != 0);
@@ -6787,35 +6782,35 @@
if (count == 0)
{
/* Ranges have already been used up before. None is left for read. */
- range= 0;
+ last_range= 0;
DBUG_RETURN(HA_ERR_END_OF_FILE);
}
- range= *(cur_range++);
+ last_range= *(cur_range++);
- start_key.key= (const byte*) range->min_key;
- start_key.length= min(range->min_length, prefix_length);
- start_key.flag= ((range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
- (range->flag & EQ_RANGE) ?
+ start_key.key= (const byte*) last_range->min_key;
+ start_key.length= min(last_range->min_length, prefix_length);
+ start_key.flag= ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
+ (last_range->flag & EQ_RANGE) ?
HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT);
- end_key.key= (const byte*) range->max_key;
- end_key.length= min(range->max_length, prefix_length);
+ end_key.key= (const byte*) last_range->max_key;
+ end_key.length= min(last_range->max_length, prefix_length);
/*
We use READ_AFTER_KEY here because if we are reading on a key
prefix we want to find all keys with this prefix
*/
- end_key.flag= (range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY :
+ end_key.flag= (last_range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY :
HA_READ_AFTER_KEY);
- result= file->read_range_first(range->min_length ? &start_key : 0,
- range->max_length ? &end_key : 0,
- test(range->flag & EQ_RANGE),
+ result= file->read_range_first(last_range->min_length ? &start_key : 0,
+ last_range->max_length ? &end_key : 0,
+ test(last_range->flag & EQ_RANGE),
sorted);
- if (range->flag == (UNIQUE_RANGE | EQ_RANGE))
- range=0; // Stop searching
+ if (last_range->flag == (UNIQUE_RANGE | EQ_RANGE))
+ last_range= 0; // Stop searching
if (result != HA_ERR_END_OF_FILE)
DBUG_RETURN(result);
- range=0; // No matching rows; go to next range
+ last_range= 0; // No matching rows; go to next range
}
}
@@ -6829,11 +6824,11 @@
for (;;)
{
int result;
- if (range)
+ if (last_range)
{
// Already read through key
- result= file->index_next_same(record, (byte*) range->min_key,
- range->min_length);
+ result= file->index_next_same(record, (byte*) last_range->min_key,
+ last_range->min_length);
if (result != HA_ERR_END_OF_FILE)
DBUG_RETURN(result);
}
@@ -6842,18 +6837,18 @@
if (count == 0)
{
/* Ranges have already been used up before. None is left for read. */
- range= 0;
+ last_range= 0;
DBUG_RETURN(HA_ERR_END_OF_FILE);
}
- range= *(cur_range++);
+ last_range= *(cur_range++);
result= file->index_read(record,
- (byte*) range->min_key,
- range->min_length,
- (ha_rkey_function)(range->flag ^ GEOM_FLAG));
+ (byte*) last_range->min_key,
+ last_range->min_length,
+ (ha_rkey_function)(last_range->flag ^ GEOM_FLAG));
if (result != HA_ERR_KEY_NOT_FOUND)
DBUG_RETURN(result);
- range=0; // Not found, to next range
+ last_range= 0; // Not found, to next range
}
}
@@ -6878,7 +6873,7 @@
bool QUICK_RANGE_SELECT::row_in_ranges()
{
- QUICK_RANGE *range;
+ QUICK_RANGE *res;
uint min= 0;
uint max= ranges.elements - 1;
uint mid= (max + min)/2;
@@ -6894,8 +6889,8 @@
max= mid;
mid= (min + max) / 2;
}
- range= *(QUICK_RANGE**)dynamic_array_ptr(&ranges, mid);
- return (!cmp_next(range) && !cmp_prev(range));
+ res= *(QUICK_RANGE**)dynamic_array_ptr(&ranges, mid);
+ return (!cmp_next(res) && !cmp_prev(res));
}
/*
@@ -6909,14 +6904,14 @@
*/
QUICK_SELECT_DESC::QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q,
- uint used_key_parts)
+ uint used_key_parts_arg)
: QUICK_RANGE_SELECT(*q), rev_it(rev_ranges)
{
QUICK_RANGE *r;
QUICK_RANGE **pr= (QUICK_RANGE**)ranges.buffer;
- QUICK_RANGE **last_range= pr + ranges.elements;
- for (; pr!=last_range; pr++)
+ QUICK_RANGE **end_range= pr + ranges.elements;
+ for (; pr!=end_range; pr++)
rev_ranges.push_front(*pr);
/* Remove EQ_RANGE flag for keys that are not using the full key */
@@ -6950,11 +6945,11 @@
for (;;)
{
int result;
- if (range)
+ if (last_range)
{ // Already read through key
- result = ((range->flag & EQ_RANGE)
- ? file->index_next_same(record, (byte*) range->min_key,
- range->min_length) :
+ result = ((last_range->flag & EQ_RANGE)
+ ? file->index_next_same(record, (byte*) last_range->min_key,
+ last_range->min_length) :
file->index_prev(record));
if (!result)
{
@@ -6965,47 +6960,49 @@
DBUG_RETURN(result);
}
- if (!(range=rev_it++))
+ if (!(last_range= rev_it++))
DBUG_RETURN(HA_ERR_END_OF_FILE); // All ranges used
- if (range->flag & NO_MAX_RANGE) // Read last record
+ if (last_range->flag & NO_MAX_RANGE) // Read last record
{
int local_error;
if ((local_error=file->index_last(record)))
DBUG_RETURN(local_error); // Empty table
- if (cmp_prev(range) == 0)
+ if (cmp_prev(last_range) == 0)
DBUG_RETURN(0);
- range=0; // No matching records; go to next range
+ last_range= 0; // No match; go to next range
continue;
}
- if (range->flag & EQ_RANGE)
+ if (last_range->flag & EQ_RANGE)
{
- result = file->index_read(record, (byte*) range->max_key,
- range->max_length, HA_READ_KEY_EXACT);
+ result= file->index_read(record, (byte*) last_range->max_key,
+ last_range->max_length, HA_READ_KEY_EXACT);
}
else
{
- DBUG_ASSERT(range->flag & NEAR_MAX || range_reads_after_key(range));
- result=file->index_read(record, (byte*) range->max_key,
- range->max_length,
- ((range->flag & NEAR_MAX) ?
- HA_READ_BEFORE_KEY : HA_READ_PREFIX_LAST_OR_PREV));
+ DBUG_ASSERT(last_range->flag & NEAR_MAX ||
+ range_reads_after_key(last_range));
+ result=file->index_read(record, (byte*) last_range->max_key,
+ last_range->max_length,
+ ((last_range->flag & NEAR_MAX) ?
+ HA_READ_BEFORE_KEY :
+ HA_READ_PREFIX_LAST_OR_PREV));
}
if (result)
{
if (result != HA_ERR_KEY_NOT_FOUND)
DBUG_RETURN(result);
- range=0; // Not found, to next range
+ last_range= 0; // Not found, to next range
continue;
}
- if (cmp_prev(range) == 0)
+ if (cmp_prev(last_range) == 0)
{
- if (range->flag == (UNIQUE_RANGE | EQ_RANGE))
- range = 0; // Stop searching
+ if (last_range->flag == (UNIQUE_RANGE | EQ_RANGE))
+ last_range= 0; // Stop searching
DBUG_RETURN(0); // Found key is in range
}
- range = 0; // To next range
+ last_range= 0; // To next range
}
}
@@ -9485,23 +9482,9 @@
}
-static void print_rowid(byte* val, int len)
-{
- byte *pb;
- DBUG_LOCK_FILE;
- fputc('\"', DBUG_FILE);
- for (pb= val; pb!= val + len; ++pb)
- fprintf(DBUG_FILE, "%c", *pb);
- fprintf(DBUG_FILE, "\", hex: ");
-
- for (pb= val; pb!= val + len; ++pb)
- fprintf(DBUG_FILE, "%x ", *pb);
- fputc('\n', DBUG_FILE);
- DBUG_UNLOCK_FILE;
-}
-
void QUICK_RANGE_SELECT::dbug_dump(int indent, bool verbose)
{
+ /* purecov: begin inspected */
fprintf(DBUG_FILE, "%*squick range select, key %s, length: %d\n",
indent, "", head->key_info[index].name, max_used_key_length);
@@ -9509,8 +9492,8 @@
{
QUICK_RANGE *range;
QUICK_RANGE **pr= (QUICK_RANGE**)ranges.buffer;
- QUICK_RANGE **last_range= pr + ranges.elements;
- for (; pr!=last_range; ++pr)
+ QUICK_RANGE **end_range= pr + ranges.elements;
+ for (; pr != end_range; ++pr)
{
fprintf(DBUG_FILE, "%*s", indent + 2, "");
range= *pr;
@@ -9535,6 +9518,7 @@
fputs("\n",DBUG_FILE);
}
}
+ /* purecov: end */
}
void QUICK_INDEX_MERGE_SELECT::dbug_dump(int indent, bool verbose)
--- 1.318/sql/sql_class.h 2007-01-29 16:15:37 +01:00
+++ 1.319/sql/sql_class.h 2007-01-29 16:15:37 +01:00
@@ -63,7 +63,7 @@
virtual int open(const char *opt_name)=0;
virtual void close()=0;
- virtual int log(THD *thd, my_xid xid)=0;
+ virtual int log_xid(THD *thd, my_xid xid)=0;
virtual void unlog(ulong cookie, my_xid xid)=0;
};
@@ -73,7 +73,7 @@
TC_LOG_DUMMY() {} /* Remove gcc warning */
int open(const char *opt_name) { return 0; }
void close() { }
- int log(THD *thd, my_xid xid) { return 1; }
+ int log_xid(THD *thd, my_xid xid) { return 1; }
void unlog(ulong cookie, my_xid xid) { }
};
@@ -118,7 +118,7 @@
TC_LOG_MMAP(): inited(0) {}
int open(const char *opt_name);
void close();
- int log(THD *thd, my_xid xid);
+ int log_xid(THD *thd, my_xid xid);
void unlog(ulong cookie, my_xid xid);
int recover();
@@ -252,7 +252,7 @@
int open(const char *opt_name);
void close();
- int log(THD *thd, my_xid xid);
+ int log_xid(THD *thd, my_xid xid);
void unlog(ulong cookie, my_xid xid);
int recover(IO_CACHE *log, Format_description_log_event *fdle);
void reset_bytes_written()
@@ -1838,13 +1838,14 @@
MYSQL_LOCK *lock;
Field **field;
public:
- select_create (TABLE_LIST *table,
- HA_CREATE_INFO *create_info_par,
- List<create_field> &fields_par,
- List<Key> &keys_par,
- List<Item> &select_fields,enum_duplicates duplic, bool ignore)
- :select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore), create_table(table),
- extra_fields(&fields_par),keys(&keys_par), create_info(create_info_par),
+ select_create(TABLE_LIST *table_arg,
+ HA_CREATE_INFO *create_info_par,
+ List<create_field> &fields_par,
+ List<Key> &keys_par,
+ List<Item> &select_fields,enum_duplicates duplic, bool ignore)
+ :select_insert(NULL, NULL, &select_fields, 0, 0, duplic, ignore),
+ create_table(table_arg), extra_fields(&fields_par),keys(&keys_par),
+ create_info(create_info_par),
lock(0)
{}
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
@@ -1949,7 +1950,9 @@
class select_singlerow_subselect :public select_subselect
{
public:
- select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
+ select_singlerow_subselect(Item_subselect *item_arg)
+ :select_subselect(item_arg)
+ {}
bool send_data(List<Item> &items);
};
@@ -1960,8 +1963,8 @@
bool (select_max_min_finder_subselect::*op)();
bool fmax;
public:
- select_max_min_finder_subselect(Item_subselect *item, bool mx)
- :select_subselect(item), cache(0), fmax(mx)
+ select_max_min_finder_subselect(Item_subselect *item_arg, bool mx)
+ :select_subselect(item_arg), cache(0), fmax(mx)
{}
void cleanup();
bool send_data(List<Item> &items);
@@ -1975,7 +1978,8 @@
class select_exists_subselect :public select_subselect
{
public:
- select_exists_subselect(Item_subselect *item):select_subselect(item){}
+ select_exists_subselect(Item_subselect *item_arg)
+ :select_subselect(item_arg){}
bool send_data(List<Item> &items);
};
--- 1.597/sql/sql_parse.cc 2007-01-29 16:15:37 +01:00
+++ 1.598/sql/sql_parse.cc 2007-01-29 16:15:37 +01:00
@@ -65,13 +65,12 @@
extern "C" int gethostname(char *name, int namelen);
#endif
-static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
#ifndef NO_EMBEDDED_ACCESS_CHECKS
+static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
static int check_for_max_user_connections(THD *thd, USER_CONN *uc);
static void decrease_user_connections(USER_CONN *uc);
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
static bool check_db_used(THD *thd,TABLE_LIST *tables);
-static bool check_multi_update_lock(THD *thd);
static void remove_escape(char *name);
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
const char *table_name);
@@ -671,6 +670,8 @@
safe to test and modify members of the USER_CONN structure.
*/
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
{
time_t check_time = thd->start_time ? thd->start_time : time(NULL);
@@ -688,7 +689,6 @@
DBUG_VOID_RETURN;
}
-
/*
Check if maximum queries per hour limit has been reached
returns 0 if OK.
@@ -696,7 +696,6 @@
static bool check_mqh(THD *thd, uint check_command)
{
-#ifndef NO_EMBEDDED_ACCESS_CHECKS
bool error= 0;
USER_CONN *uc=thd->user_connect;
DBUG_ENTER("check_mqh");
@@ -730,11 +729,10 @@
end:
(void) pthread_mutex_unlock(&LOCK_user_conn);
DBUG_RETURN(error);
-#else
- return (0);
-#endif /* NO_EMBEDDED_ACCESS_CHECKS */
}
+#endif /* NO_EMBEDDED_ACCESS_CHECKS */
+
static void reset_mqh(LEX_USER *lu, bool get_them= 0)
{
@@ -1594,7 +1592,7 @@
thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
thd->set_time();
VOID(pthread_mutex_lock(&LOCK_thread_count));
- thd->query_id=query_id;
+ thd->query_id= global_query_id;
if (command != COM_STATISTICS && command != COM_PING)
next_query_id();
thread_running++;
@@ -1775,7 +1773,7 @@
while (!thd->killed && thd->lex->found_semicolon && !thd->net.report_error)
{
- char *packet= thd->lex->found_semicolon;
+ char *next_packet= thd->lex->found_semicolon;
net->no_send_error= 0;
/*
Multiple queries exits, execute them individually
@@ -1783,24 +1781,24 @@
if (thd->lock || thd->open_tables || thd->derived_tables ||
thd->prelocked_mode)
close_thread_tables(thd);
- ulong length= (ulong)(packet_end-packet);
+ ulong length= (ulong)(packet_end - next_packet);
log_slow_statement(thd);
/* Remove garbage at start of query */
- while (my_isspace(thd->charset(), *packet) && length > 0)
+ while (my_isspace(thd->charset(), *next_packet) && length > 0)
{
- packet++;
+ next_packet++;
length--;
}
VOID(pthread_mutex_lock(&LOCK_thread_count));
thd->query_length= length;
- thd->query= packet;
+ thd->query= next_packet;
thd->query_id= next_query_id();
thd->set_time(); /* Reset the query start time. */
/* TODO: set thd->lex->sql_command to SQLCOM_END here */
VOID(pthread_mutex_unlock(&LOCK_thread_count));
- mysql_parse(thd, packet, length);
+ mysql_parse(thd, next_packet, length);
}
if (!(specialflag & SPECIAL_NO_PRIOR))
@@ -1817,16 +1815,12 @@
{
char *fields, *pend;
/* Locked closure of all tables */
- TABLE_LIST *locked_tables= NULL;
TABLE_LIST table_list;
LEX_STRING conv_name;
- /* Saved variable value */
- my_bool old_innodb_table_locks=
- IF_INNOBASE_DB(thd->variables.innodb_table_locks, FALSE);
+
/* used as fields initializator */
lex_start(thd, 0, 0);
-
statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
&LOCK_status);
bzero((char*) &table_list,sizeof(table_list));
@@ -2022,7 +2016,7 @@
STATUS_VAR current_global_status_var;
calc_sum_of_all_status(¤t_global_status_var);
- ulong uptime = (ulong) (thd->start_time - start_time);
+ ulong uptime = (ulong) (thd->start_time - server_start_time);
sprintf((char*) buff,
"Uptime: %lu Threads: %d Questions: %lu Slow queries: %lu Opens: %lu Flush tables: %lu Open tables: %u Queries per second avg: %.3f",
uptime,
@@ -2069,13 +2063,14 @@
{
statistic_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION],
&LOCK_status);
- enum_mysql_set_option command= (enum_mysql_set_option) uint2korr(packet);
- switch (command) {
- case MYSQL_OPTION_MULTI_STATEMENTS_ON:
+ uint opt_command= uint2korr(packet);
+
+ switch (opt_command) {
+ case (int) MYSQL_OPTION_MULTI_STATEMENTS_ON:
thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
send_eof(thd);
break;
- case MYSQL_OPTION_MULTI_STATEMENTS_OFF:
+ case (int) MYSQL_OPTION_MULTI_STATEMENTS_OFF:
thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
send_eof(thd);
break;
@@ -2417,7 +2412,7 @@
{
bool res= FALSE;
bool need_start_waiting= FALSE; // have protection against global read lock
- int result= 0;
+ int up_result= 0;
LEX *lex= thd->lex;
/* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
SELECT_LEX *select_lex= &lex->select_lex;
@@ -2561,7 +2556,7 @@
new Item_int((ulonglong)thd->variables.select_limit);
}
- select_result *result=lex->result;
+ select_result *sel_result=lex->result;
if (all_tables)
{
if (lex->orig_sql_command != SQLCOM_SHOW_STATUS_PROC &&
@@ -2588,11 +2583,11 @@
to prepend EXPLAIN to any query and receive output for it,
even if the query itself redirects the output.
*/
- if (!(result= new select_send()))
+ if (!(sel_result= new select_send()))
goto error;
else
- thd->send_explain_fields(result);
- res= mysql_explain_union(thd, &thd->lex->unit, result);
+ thd->send_explain_fields(sel_result);
+ res= mysql_explain_union(thd, &thd->lex->unit, sel_result);
if (lex->describe & DESCRIBE_EXTENDED)
{
char buff[1024];
@@ -2603,17 +2598,17 @@
push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
ER_YES, str.ptr());
}
- result->send_eof();
- delete result;
+ sel_result->send_eof();
+ delete sel_result;
}
else
{
- if (!result && !(result= new select_send()))
+ if (!sel_result && !(sel_result= new select_send()))
goto error;
query_cache_store_query(thd, all_tables);
- res= handle_select(thd, lex, result, 0);
- if (result != lex->result)
- delete result;
+ res= handle_select(thd, lex, sel_result, 0);
+ if (sel_result != lex->result)
+ delete sel_result;
}
}
break;
@@ -2948,7 +2943,7 @@
}
if (select_lex->item_list.elements) // With select
{
- select_result *result;
+ select_result *sel_result;
select_lex->options|= SELECT_NO_UNLOCK;
unit->set_limit(select_lex);
@@ -2987,20 +2982,20 @@
}
}
- if ((result= new select_create(create_table,
- &lex->create_info,
- lex->create_list,
- lex->key_list,
- select_lex->item_list,
- lex->duplicates,
- lex->ignore)))
+ if ((sel_result= new select_create(create_table,
+ &lex->create_info,
+ lex->create_list,
+ lex->key_list,
+ select_lex->item_list,
+ lex->duplicates,
+ lex->ignore)))
{
/*
CREATE from SELECT give its SELECT_LEX for SELECT,
and item_list belong to SELECT
*/
- res= handle_select(thd, lex, result, 0);
- delete result;
+ res= handle_select(thd, lex, sel_result, 0);
+ delete sel_result;
}
/* reset for PS */
lex->create_list.empty();
@@ -3315,22 +3310,23 @@
break;
DBUG_ASSERT(select_lex->offset_limit == 0);
unit->set_limit(select_lex);
- res= (result= mysql_update(thd, all_tables,
- select_lex->item_list,
- lex->value_list,
- select_lex->where,
- select_lex->order_list.elements,
- (ORDER *) select_lex->order_list.first,
- unit->select_limit_cnt,
- lex->duplicates, lex->ignore));
+ res= (up_result= mysql_update(thd, all_tables,
+ select_lex->item_list,
+ lex->value_list,
+ select_lex->where,
+ select_lex->order_list.elements,
+ (ORDER *) select_lex->order_list.first,
+ unit->select_limit_cnt,
+ lex->duplicates, lex->ignore));
/* mysql_update return 2 if we need to switch to multi-update */
- if (result != 2)
+ if (up_result != 2)
break;
+ /* Fall through */
case SQLCOM_UPDATE_MULTI:
{
DBUG_ASSERT(first_table == all_tables && first_table != 0);
/* if we switched from normal update, rights are checked */
- if (result != 2)
+ if (up_result != 2)
{
if ((res= multi_update_precheck(thd, all_tables)))
break;
@@ -3414,7 +3410,7 @@
case SQLCOM_REPLACE_SELECT:
case SQLCOM_INSERT_SELECT:
{
- select_result *result;
+ select_result *sel_result;
DBUG_ASSERT(first_table == all_tables && first_table != 0);
if ((res= insert_precheck(thd, all_tables)))
break;
@@ -3443,13 +3439,15 @@
select_lex->context.table_list=
select_lex->context.first_name_resolution_table= second_table;
res= mysql_insert_select_prepare(thd);
- if (!res && (result= new select_insert(first_table, first_table->table,
- &lex->field_list,
- &lex->update_list,
- &lex->value_list,
- lex->duplicates, lex->ignore)))
+ if (!res && (sel_result= new select_insert(first_table,
+ first_table->table,
+ &lex->field_list,
+ &lex->update_list,
+ &lex->value_list,
+ lex->duplicates,
+ lex->ignore)))
{
- res= handle_select(thd, lex, result, OPTION_SETUP_TABLES_DONE);
+ res= handle_select(thd, lex, sel_result, OPTION_SETUP_TABLES_DONE);
/*
Invalidate the table in the query cache if something changed
after unlocking when changes become visible.
@@ -3467,7 +3465,7 @@
first_table->next_local= save_table;
thd->lock=0;
}
- delete result;
+ delete sel_result;
}
/* revert changes for SP */
select_lex->table_list.first= (byte*) first_table;
@@ -3532,7 +3530,7 @@
DBUG_ASSERT(first_table == all_tables && first_table != 0);
TABLE_LIST *aux_tables=
(TABLE_LIST *)thd->lex->auxiliary_table_list.first;
- multi_delete *result;
+ multi_delete *del_result;
if (!thd->locked_tables &&
!(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
@@ -3557,8 +3555,8 @@
if ((res= mysql_multi_delete_prepare(thd)))
goto error;
- if (!thd->is_fatal_error && (result= new multi_delete(aux_tables,
- lex->table_count)))
+ if (!thd->is_fatal_error &&
+ (del_result= new multi_delete(aux_tables, lex->table_count)))
{
res= mysql_select(thd, &select_lex->ref_pointer_array,
select_lex->get_table_list(),
@@ -3570,8 +3568,8 @@
select_lex->options | thd->options |
SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
OPTION_SETUP_TABLES_DONE,
- result, unit, select_lex);
- delete result;
+ del_result, unit, select_lex);
+ delete del_result;
}
else
res= TRUE; // Error
@@ -4251,7 +4249,7 @@
{
uint namelen;
char *name;
- int result= SP_INTERNAL_ERROR;
+ int sp_result= SP_INTERNAL_ERROR;
DBUG_ASSERT(lex->sphead != 0);
DBUG_ASSERT(lex->sphead->m_db.str); /* Must be initialized in the parser */
@@ -4324,18 +4322,18 @@
if (!lex->definer)
{
- bool res= FALSE;
+ bool local_res= FALSE;
Query_arena original_arena;
Query_arena *ps_arena = thd->activate_stmt_arena_if_needed(&original_arena);
if (!(lex->definer= create_default_definer(thd)))
- res= TRUE;
+ local_res= TRUE;
if (ps_arena)
thd->restore_active_arena(ps_arena, &original_arena);
/* Error has been already reported. */
- if (res)
+ if (local_res)
goto create_sp_error;
if (thd->slave_thread)
@@ -4375,8 +4373,8 @@
}
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
- res= (result= lex->sphead->create(thd));
- switch (result) {
+ res= (sp_result= lex->sphead->create(thd));
+ switch (sp_result) {
case SP_OK:
#ifndef NO_EMBEDDED_ACCESS_CHECKS
/* only add privileges if really neccessary */
@@ -4416,7 +4414,7 @@
lex->unit.cleanup();
delete lex->sphead;
lex->sphead= 0;
- if (result != SP_OK )
+ if (sp_result != SP_OK )
goto error;
send_ok(thd);
break; /* break super switch */
@@ -4528,7 +4526,7 @@
case SQLCOM_ALTER_PROCEDURE:
case SQLCOM_ALTER_FUNCTION:
{
- int result;
+ int sp_result;
sp_head *sp;
st_sp_chistics chistics;
@@ -4543,7 +4541,7 @@
if (! sp)
{
if (lex->spname->m_db.str)
- result= SP_KEY_NOT_FOUND;
+ sp_result= SP_KEY_NOT_FOUND;
else
{
my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
@@ -4568,7 +4566,7 @@
{
my_message(ER_BINLOG_UNSAFE_ROUTINE,
ER(ER_BINLOG_UNSAFE_ROUTINE), MYF(0));
- result= SP_INTERNAL_ERROR;
+ sp_result= SP_INTERNAL_ERROR;
}
else
{
@@ -4578,15 +4576,15 @@
follow the restrictions that log-bin-trust-function-creators=0
already puts on CREATE FUNCTION.
*/
+ /* Conditionally writes to binlog */
if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
- /* Conditionally writes to binlog */
- result= sp_update_procedure(thd, lex->spname, &lex->sp_chistics);
+ sp_result= sp_update_procedure(thd, lex->spname,
+ &lex->sp_chistics);
else
- /* Conditionally writes to binlog */
- result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
+ sp_result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
}
}
- switch (result)
+ switch (sp_result)
{
case SP_OK:
send_ok(thd);
@@ -4605,13 +4603,13 @@
case SQLCOM_DROP_PROCEDURE:
case SQLCOM_DROP_FUNCTION:
{
- int result;
+ int sp_result;
int type= (lex->sql_command == SQLCOM_DROP_PROCEDURE ?
TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION);
- result= sp_routine_exists_in_table(thd, type, lex->spname);
+ sp_result= sp_routine_exists_in_table(thd, type, lex->spname);
mysql_reset_errors(thd, 0);
- if (result == SP_OK)
+ if (sp_result == SP_OK)
{
char *db= lex->spname->m_db.str;
char *name= lex->spname->m_name.str;
@@ -4632,12 +4630,11 @@
ER(ER_PROC_AUTO_REVOKE_FAIL));
}
#endif
- if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
/* Conditionally writes to binlog */
- result= sp_drop_procedure(thd, lex->spname); /* Conditionally writes to binlog */
+ if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
+ sp_result= sp_drop_procedure(thd, lex->spname);
else
- /* Conditionally writes to binlog */
- result= sp_drop_function(thd, lex->spname); /* Conditionally writes to binlog */
+ sp_result= sp_drop_function(thd, lex->spname);
}
else
{
@@ -4661,16 +4658,15 @@
}
#endif
if (lex->spname->m_db.str)
- result= SP_KEY_NOT_FOUND;
+ sp_result= SP_KEY_NOT_FOUND;
else
{
my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
goto error;
}
}
- res= result;
- switch (result)
- {
+ res= sp_result;
+ switch (sp_result) {
case SP_OK:
send_ok(thd);
break;
@@ -5306,7 +5302,9 @@
{
uint found=0;
ulong found_access=0;
+#ifndef EMBEDDED_LIBRARY
TABLE_LIST *org_tables= tables;
+#endif
TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
Security_context *sctx= thd->security_ctx, *backup_ctx= thd->security_ctx;
/*
@@ -6511,18 +6509,18 @@
0 on success
*/
-bool st_select_lex_unit::add_fake_select_lex(THD *thd)
+bool st_select_lex_unit::add_fake_select_lex(THD *thd_arg)
{
SELECT_LEX *first_sl= first_select();
DBUG_ENTER("add_fake_select_lex");
DBUG_ASSERT(!fake_select_lex);
- if (!(fake_select_lex= new (thd->mem_root) SELECT_LEX()))
+ if (!(fake_select_lex= new (thd_arg->mem_root) SELECT_LEX()))
DBUG_RETURN(1);
fake_select_lex->include_standalone(this,
(SELECT_LEX_NODE**)&fake_select_lex);
fake_select_lex->select_number= INT_MAX;
- fake_select_lex->parent_lex= thd->lex; /* Used in init_query. */
+ fake_select_lex->parent_lex= thd_arg->lex; /* Used in init_query. */
fake_select_lex->make_empty_select();
fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
fake_select_lex->select_limit= 0;
@@ -6542,9 +6540,9 @@
*/
global_parameters= fake_select_lex;
fake_select_lex->no_table_names_allowed= 1;
- thd->lex->current_select= fake_select_lex;
+ thd_arg->lex->current_select= fake_select_lex;
}
- thd->lex->pop_context();
+ thd_arg->lex->pop_context();
DBUG_RETURN(0);
}
--- 1.335/sql/sql_show.cc 2007-01-29 16:15:37 +01:00
+++ 1.336/sql/sql_show.cc 2007-01-29 16:15:37 +01:00
@@ -28,11 +28,11 @@
#include "ha_berkeley.h" // For berkeley_show_logs
#endif
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
static const char *grant_names[]={
"select","insert","update","delete","create","drop","reload","shutdown",
"process","file","grant","references","index","alter"};
-#ifndef NO_EMBEDDED_ACCESS_CHECKS
static TYPELIB grant_types = { sizeof(grant_names)/sizeof(char **),
"grant_types",
grant_names, NULL};
@@ -462,10 +462,10 @@
bool mysqld_show_create_db(THD *thd, char *dbname,
HA_CREATE_INFO *create_info)
{
- Security_context *sctx= thd->security_ctx;
char buff[2048];
String buffer(buff, sizeof(buff), system_charset_info);
#ifndef NO_EMBEDDED_ACCESS_CHECKS
+ Security_context *sctx= thd->security_ctx;
uint db_access;
#endif
HA_CREATE_INFO create;
@@ -794,7 +794,7 @@
store_create_info(THD *thd, TABLE_LIST *table_list, String *packet)
{
List<Item> field_list;
- char tmp[MAX_FIELD_WIDTH], *for_str, buff[128], *end;
+ char tmp[MAX_FIELD_WIDTH], *for_str, buff[128];
const char *alias;
String type(tmp, sizeof(tmp), system_charset_info);
Field **ptr,*field;
@@ -1036,8 +1036,9 @@
but may extrapolate its existence from that of an AUTO_INCREMENT column.
*/
- if(create_info.auto_increment_value > 1)
+ if (create_info.auto_increment_value > 1)
{
+ char *end;
packet->append(" AUTO_INCREMENT=", 16);
end= longlong10_to_str(create_info.auto_increment_value, buff,10);
packet->append(buff, (uint) (end - buff));
@@ -1059,6 +1060,7 @@
if (share->min_rows)
{
+ char *end;
packet->append(STRING_WITH_LEN(" MIN_ROWS="));
end= longlong10_to_str(share->min_rows, buff, 10);
packet->append(buff, (uint) (end- buff));
@@ -1066,6 +1068,7 @@
if (share->max_rows && !table_list->schema_table)
{
+ char *end;
packet->append(STRING_WITH_LEN(" MAX_ROWS="));
end= longlong10_to_str(share->max_rows, buff, 10);
packet->append(buff, (uint) (end - buff));
@@ -1073,6 +1076,7 @@
if (share->avg_row_length)
{
+ char *end;
packet->append(STRING_WITH_LEN(" AVG_ROW_LENGTH="));
end= longlong10_to_str(share->avg_row_length, buff,10);
packet->append(buff, (uint) (end - buff));
@@ -1443,7 +1447,7 @@
long nr;
if (show_type == SHOW_SYS)
{
- show_type= ((sys_var*) value)->type();
+ show_type= ((sys_var*) value)->show_type();
value= (char*) ((sys_var*) value)->value_ptr(thd, value_type,
&null_lex_str);
}
@@ -1489,7 +1493,7 @@
break;
}
case SHOW_STARTTIME:
- nr= (long) (thd->query_start() - start_time);
+ nr= (long) (thd->query_start() - server_start_time);
end= int10_to_str(nr, buff, 10);
break;
case SHOW_QUESTION:
@@ -2118,19 +2122,21 @@
List<char> bases;
List_iterator_fast<char> it(bases);
COND *partial_cond;
- Security_context *sctx= thd->security_ctx;
uint derived_tables= lex->derived_tables;
int error= 1;
db_type not_used;
Open_tables_state open_tables_state_backup;
bool save_view_prepare_mode= lex->view_prepare_mode;
Query_tables_list query_tables_list_backup;
- lex->view_prepare_mode= TRUE;
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+ Security_context *sctx= thd->security_ctx;
+#endif
DBUG_ENTER("get_all_tables");
LINT_INIT(end);
LINT_INIT(len);
+ lex->view_prepare_mode= TRUE;
lex->reset_n_backup_query_tables_list(&query_tables_list_backup);
/*
@@ -2368,7 +2374,9 @@
bool with_i_schema;
HA_CREATE_INFO create;
TABLE *table= tables->table;
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
Security_context *sctx= thd->security_ctx;
+#endif
DBUG_ENTER("fill_schema_shemata");
if (make_db_list(thd, &files, &idx_field_vals,
@@ -2720,7 +2728,7 @@
field->real_type() == MYSQL_TYPE_VARCHAR || // For varbinary type
field->real_type() == MYSQL_TYPE_STRING) // For binary type
{
- uint32 octet_max_length= field->max_length();
+ uint32 octet_max_length= field->max_display_length();
if (is_blob && octet_max_length != (uint32) 4294967295U)
octet_max_length /= field->charset()->mbmaxlen;
longlong char_max_len= is_blob ?
@@ -2750,10 +2758,10 @@
case FIELD_TYPE_LONG:
case FIELD_TYPE_LONGLONG:
case FIELD_TYPE_INT24:
- field_length= field->max_length() - 1;
+ field_length= field->max_display_length() - 1;
break;
case FIELD_TYPE_BIT:
- field_length= field->max_length();
+ field_length= field->max_display_length();
decimals= -1; // return NULL
break;
case FIELD_TYPE_FLOAT:
@@ -3420,8 +3428,8 @@
show_table->file->get_foreign_key_list(thd, &f_key_list);
FOREIGN_KEY_INFO *f_key_info;
- List_iterator_fast<FOREIGN_KEY_INFO> it(f_key_list);
- while ((f_key_info= it++))
+ List_iterator_fast<FOREIGN_KEY_INFO> fkey_it(f_key_list);
+ while ((f_key_info= fkey_it++))
{
LEX_STRING *f_info;
LEX_STRING *r_info;
--- 1.50/mysql-test/t/mysqltest.test 2007-01-29 16:15:37 +01:00
+++ 1.51/mysql-test/t/mysqltest.test 2007-01-29 16:15:37 +01:00
@@ -1,6 +1,9 @@
# This test should work in embedded server after mysqltest is fixed
-- source include/not_embedded.inc
+# This test uses chmod, can't be run with root permissions
+-- source include/not_as_root.inc
+
# ============================================================================
#
# Test of mysqltest itself
--- 1.272/client/mysqltest.c 2007-01-29 16:15:37 +01:00
+++ 1.273/client/mysqltest.c 2007-01-29 16:15:37 +01:00
@@ -84,10 +84,10 @@
};
static int record= 0, opt_sleep= -1;
-static char *db= 0, *pass= 0;
-const char *user= 0, *host= 0, *unix_sock= 0, *opt_basedir= "./";
+static char *opt_db= 0, *opt_pass= 0;
+const char *opt_user= 0, *opt_host= 0, *unix_sock= 0, *opt_basedir= "./";
const char *opt_include= 0, *opt_charsets_dir;
-static int port= 0;
+static int opt_port= 0;
static int opt_max_connect_retries;
static my_bool opt_compress= 0, silent= 0, verbose= 0;
static my_bool tty_password= 0;
@@ -609,15 +609,14 @@
int i;
const char *ptr= arguments;
const char *start;
-
DBUG_ENTER("check_command_args");
DBUG_PRINT("enter", ("num_args: %d", num_args));
+
for (i= 0; i < num_args; i++)
{
const struct command_arg *arg= &args[i];
- switch (arg->type)
- {
+ switch (arg->type) {
/* A string */
case ARG_STRING:
/* Skip leading spaces */
@@ -782,7 +781,7 @@
dynstr_free(&ds_progress);
dynstr_free(&ds_warning_messages);
free_all_replace();
- my_free(pass,MYF(MY_ALLOW_ZERO_PTR));
+ my_free(opt_pass,MYF(MY_ALLOW_ZERO_PTR));
free_defaults(default_argv);
free_re();
#ifdef __WIN__
@@ -1312,7 +1311,7 @@
void var_query_set(VAR *var, const char *query, const char** query_end)
{
- char* end = (char*)((query_end && *query_end) ?
+ char *end = (char*)((query_end && *query_end) ?
*query_end : query + strlen(query));
MYSQL_RES *res;
MYSQL_ROW row;
@@ -1343,7 +1342,6 @@
DYNAMIC_STRING result;
uint i;
ulong *lengths;
- char *end;
#ifdef NOT_YET
MYSQL_FIELD *fields= mysql_fetch_fields(res);
#endif
@@ -2128,6 +2126,7 @@
int do_echo(struct st_command *command)
{
DYNAMIC_STRING ds_echo;
+ DBUG_ENTER("do_echo");
init_dynamic_string(&ds_echo, "", command->query_len, 256);
do_eval(&ds_echo, command->first_argument, command->end, FALSE);
@@ -2135,7 +2134,7 @@
dynstr_append_mem(&ds_res, "\n", 1);
dynstr_free(&ds_echo);
command->last_argument= command->end;
- return(0);
+ DBUG_RETURN(0);
}
@@ -2431,7 +2430,6 @@
char *p= command->first_argument;
char *var_name, *var_name_end;
DYNAMIC_STRING let_rhs_expr;
-
DBUG_ENTER("do_let");
init_dynamic_string(&let_rhs_expr, "", 512, 2048);
@@ -3111,7 +3109,7 @@
void do_connect(struct st_command *command)
{
- int con_port= port;
+ int con_port= opt_port;
char *con_options;
bool con_ssl= 0, con_compress= 0;
char *ptr;
@@ -3247,13 +3245,12 @@
/* Use default db name */
if (ds_database.length == 0)
- dynstr_set(&ds_database, db);
+ dynstr_set(&ds_database, opt_db);
/* Special database to allow one to connect without a database name */
if (ds_database.length && !strcmp(ds_database.str,"*NO-ONE*"))
dynstr_set(&ds_database, "");
-
if (connect_n_handle_errors(command, &next_con->mysql,
ds_host.str,ds_user.str,
ds_password.str, ds_database.str,
@@ -3677,7 +3674,7 @@
void convert_to_format_v1(char* query)
{
int last_c_was_quote= 0;
- char *p= query, *write= query;
+ char *p= query, *to= query;
char *end= strend(query);
char last_c;
@@ -3685,7 +3682,7 @@
{
if (*p == '\n' && !last_c_was_quote)
{
- *write++ = *p++; /* Save the newline */
+ *to++ = *p++; /* Save the newline */
/* Skip any spaces on next line */
while (*p && my_isspace(charset_info, *p))
@@ -3696,19 +3693,19 @@
else if (*p == '\'' || *p == '"' || *p == '`')
{
last_c= *p;
- *write++ = *p++;
+ *to++ = *p++;
/* Copy anything until the next quote of same type */
while (*p && *p != last_c)
- *write++ = *p++;
+ *to++ = *p++;
- *write++ = *p++;
+ *to++ = *p++;
last_c_was_quote= 1;
}
else
{
- *write++ = *p++;
+ *to++ = *p++;
last_c_was_quote= 0;
}
}
@@ -3826,19 +3823,17 @@
Create a command from a set of lines
SYNOPSIS
- read_command()
- command_ptr pointer where to return the new query
+ read_command()
+ command_ptr pointer where to return the new query
DESCRIPTION
- Converts lines returned by read_line into a command, this involves
- parsing the first word in the read line to find the command type.
-
+ Converts lines returned by read_line into a command, this involves
+ parsing the first word in the read line to find the command type.
A -- comment may contain a valid query as the first word after the
comment start. Thus it's always checked to see if that is the case.
The advantage with this approach is to be able to execute commands
terminated by new line '\n' regardless how many "delimiter" it contain.
-
*/
#define MAX_QUERY (256*1024) /* 256K -- a test in sp-big is >128K */
@@ -3924,7 +3919,7 @@
{"cursor-protocol", OPT_CURSOR_PROTOCOL, "Use cursors for prepared statements.",
(gptr*) &cursor_protocol, (gptr*) &cursor_protocol, 0,
GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
- {"database", 'D', "Database to use.", (gptr*) &db, (gptr*) &db, 0,
+ {"database", 'D', "Database to use.", (gptr*) &opt_db, (gptr*) &opt_db, 0,
GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#ifdef DBUG_OFF
{"debug", '#', "This is a non-debug version. Catch this and exit",
@@ -3933,7 +3928,7 @@
{"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
- {"host", 'h', "Connect to host.", (gptr*) &host, (gptr*) &host, 0,
+ {"host", 'h', "Connect to host.", (gptr*) &opt_host, (gptr*) &opt_host, 0,
GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"include", 'i', "Include SQL before each test case.", (gptr*) &opt_include,
(gptr*) &opt_include, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
@@ -3947,8 +3942,8 @@
GET_INT, REQUIRED_ARG, 500, 1, 10000, 0, 0, 0},
{"password", 'p', "Password to use when connecting to server.",
0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
- {"port", 'P', "Port number to use for connection.", (gptr*) &port,
- (gptr*) &port, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+ {"port", 'P', "Port number to use for connection.", (gptr*) &opt_port,
+ (gptr*) &opt_port, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"ps-protocol", OPT_PS_PROTOCOL, "Use prepared statements protocol for communication",
(gptr*) &ps_protocol, (gptr*) &ps_protocol, 0,
GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
@@ -3984,8 +3979,8 @@
0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"tmpdir", 't', "Temporary directory where sockets are put.",
0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
- {"user", 'u', "User for login.", (gptr*) &user, (gptr*) &user, 0, GET_STR,
- REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+ {"user", 'u', "User for login.", (gptr*) &opt_user, (gptr*) &opt_user, 0,
+ GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"verbose", 'v', "Write more.", (gptr*) &verbose, (gptr*) &verbose, 0,
GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
{"version", 'V', "Output version information and exit.",
@@ -4112,8 +4107,8 @@
case 'p':
if (argument)
{
- my_free(pass, MYF(MY_ALLOW_ZERO_PTR));
- pass= my_strdup(argument, MYF(MY_FAE));
+ my_free(opt_pass, MYF(MY_ALLOW_ZERO_PTR));
+ opt_pass= my_strdup(argument, MYF(MY_FAE));
while (*argument) *argument++= 'x'; /* Destroy argument */
tty_password= 0;
}
@@ -4150,7 +4145,7 @@
exit(0);
case '?':
usage();
- exit(1);
+ exit(0);
}
return 0;
}
@@ -4170,9 +4165,9 @@
exit(1);
}
if (argc == 1)
- db= *argv;
+ opt_db= *argv;
if (tty_password)
- pass=get_tty_password(NullS);
+ opt_pass= get_tty_password(NullS); /* purify tested */
return 0;
}
@@ -4455,13 +4450,13 @@
void append_stmt_result(DYNAMIC_STRING *ds, MYSQL_STMT *stmt,
MYSQL_FIELD *fields, uint num_fields)
{
- MYSQL_BIND *bind;
+ MYSQL_BIND *my_bind;
my_bool *is_null;
ulong *length;
uint i;
/* Allocate array with bind structs, lengths and NULL flags */
- bind= (MYSQL_BIND*) my_malloc(num_fields * sizeof(MYSQL_BIND),
+ my_bind= (MYSQL_BIND*) my_malloc(num_fields * sizeof(MYSQL_BIND),
MYF(MY_WME | MY_FAE | MY_ZEROFILL));
length= (ulong*) my_malloc(num_fields * sizeof(ulong),
MYF(MY_WME | MY_FAE));
@@ -4472,25 +4467,25 @@
for (i= 0; i < num_fields; i++)
{
uint max_length= fields[i].max_length + 1;
- bind[i].buffer_type= MYSQL_TYPE_STRING;
- bind[i].buffer= (char *)my_malloc(max_length, MYF(MY_WME | MY_FAE));
- bind[i].buffer_length= max_length;
- bind[i].is_null= &is_null[i];
- bind[i].length= &length[i];
+ my_bind[i].buffer_type= MYSQL_TYPE_STRING;
+ my_bind[i].buffer= (char *)my_malloc(max_length, MYF(MY_WME | MY_FAE));
+ my_bind[i].buffer_length= max_length;
+ my_bind[i].is_null= &is_null[i];
+ my_bind[i].length= &length[i];
DBUG_PRINT("bind", ("col[%d]: buffer_type: %d, buffer_length: %lu",
- i, bind[i].buffer_type, bind[i].buffer_length));
+ i, my_bind[i].buffer_type, my_bind[i].buffer_length));
}
- if (mysql_stmt_bind_result(stmt, bind))
+ if (mysql_stmt_bind_result(stmt, my_bind))
die("mysql_stmt_bind_result failed: %d: %s",
mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
while (mysql_stmt_fetch(stmt) == 0)
{
for (i= 0; i < num_fields; i++)
- append_field(ds, i, &fields[i], (const char *) bind[i].buffer,
- *bind[i].length, *bind[i].is_null);
+ append_field(ds, i, &fields[i], (const char *) my_bind[i].buffer,
+ *my_bind[i].length, *my_bind[i].is_null);
if (!display_result_vertically)
dynstr_append_mem(ds, "\n", 1);
}
@@ -4502,10 +4497,10 @@
for (i= 0; i < num_fields; i++)
{
/* Free data for output */
- my_free((gptr)bind[i].buffer, MYF(MY_WME | MY_FAE));
+ my_free((gptr)my_bind[i].buffer, MYF(MY_WME | MY_FAE));
}
/* Free array with bind structs, lengths and NULL flags */
- my_free((gptr)bind , MYF(MY_WME | MY_FAE));
+ my_free((gptr)my_bind , MYF(MY_WME | MY_FAE));
my_free((gptr)length , MYF(MY_WME | MY_FAE));
my_free((gptr)is_null , MYF(MY_WME | MY_FAE));
}
@@ -4642,17 +4637,14 @@
/*
Run query using MySQL C API
- SYNPOSIS
- run_query_normal
- mysql - mysql handle
- command - currrent command pointer
- flags -flags indicating wheter to SEND and/or REAP
- query - query string to execute
- query_len - length query string to execute
- ds - output buffer wherte to store result form query
-
- RETURN VALUE
- error - function will not return
+ SYNOPSIS
+ run_query_normal()
+ mysql mysql handle
+ command current command pointer
+ flags flags indicating if we should SEND and/or REAP
+ query query string to execute
+ query_len length query string to execute
+ ds output buffer where to store result form query
*/
void run_query_normal(struct st_connection *cn, struct st_command *command,
@@ -5169,15 +5161,14 @@
/*
Run query
+ SYNPOSIS
+ run_query()
+ mysql mysql handle
+ command currrent command pointer
+
flags control the phased/stages of query execution to be performed
if QUERY_SEND_FLAG bit is on, the query will be sent. If QUERY_REAP_FLAG
is on the result will be read - for regular query, both bits must be on
-
- SYNPOSIS
- run_query
- mysql - mysql handle
- command - currrent command pointer
-
*/
void run_query(struct st_connection *cn, struct st_command *command, int flags)
@@ -5192,6 +5183,7 @@
my_bool view_created= 0, sp_created= 0;
my_bool complete_query= ((flags & QUERY_SEND_FLAG) &&
(flags & QUERY_REAP_FLAG));
+ DBUG_ENTER("run_query");
init_dynamic_string(&ds_warnings, NULL, 0, 256);
@@ -5357,7 +5349,6 @@
if (command->require_file[0])
{
-
/* A result file was specified for _this_ query
and the output should be checked against an already
existing file which has been specified using --require or --result
@@ -5370,6 +5361,7 @@
dynstr_free(&ds_result);
if (command->type == Q_EVAL)
dynstr_free(&eval_query);
+ DBUG_VOID_RETURN;
}
/****************************************************************************/
@@ -5697,8 +5689,8 @@
if (!(cur_con->name = my_strdup("default", MYF(MY_WME))))
die("Out of memory");
- safe_connect(&cur_con->mysql, cur_con->name, host, user, pass,
- db, port, unix_sock);
+ safe_connect(&cur_con->mysql, cur_con->name, opt_host, opt_user, opt_pass,
+ opt_db, opt_port, unix_sock);
/* Use all time until exit if no explicit 'start_timer' */
timer_start= timer_now();
@@ -6062,8 +6054,6 @@
/* Dump warning messages */
if (result_file_name && ds_warning_messages.length)
dump_warning_messages();
-
- dynstr_free(&ds_res);
timer_output();
free_used_memory();
--- 1.27/server-tools/instance-manager/guardian.cc 2007-01-29 16:15:37 +01:00
+++ 1.28/server-tools/instance-manager/guardian.cc 2007-01-29 16:15:37 +01:00
@@ -77,7 +77,7 @@
void Guardian_thread::process_instance(Instance *instance,
GUARD_NODE *current_node,
- LIST **guarded_instances,
+ LIST **guarded_instances_arg,
LIST *node)
{
uint waitchild= (uint) Instance::DEFAULT_SHUTDOWN_DELAY;
@@ -93,7 +93,7 @@
/* this returns true if and only if an instance was stopped for sure */
if (instance->is_crashed())
- *guarded_instances= list_delete(*guarded_instances, node);
+ *guarded_instances_arg= list_delete(*guarded_instances_arg, node);
else if ( (uint) (current_time - current_node->last_checked) > waitchild)
{
instance->kill_instance(SIGKILL);
@@ -101,7 +101,7 @@
Later we do node= node->next. This is ok, as we are only removing
the node from the list. The pointer to the next one is still valid.
*/
- *guarded_instances= list_delete(*guarded_instances, node);
+ *guarded_instances_arg= list_delete(*guarded_instances_arg, node);
}
return;
--- 1.219/tests/mysql_client_test.c 2007-01-29 16:15:37 +01:00
+++ 1.220/tests/mysql_client_test.c 2007-01-29 16:15:37 +01:00
@@ -11013,7 +11013,7 @@
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
rc= my_process_stmt_result(stmt);
- assert(1 == rc);
+ DIE_UNLESS(1 == rc);
}
mysql_stmt_close(stmt);
@@ -11056,7 +11056,7 @@
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
rc= my_process_stmt_result(stmt);
- assert(4 == rc);
+ DIE_UNLESS(4 == rc);
}
mysql_stmt_close(stmt);
@@ -11139,7 +11139,7 @@
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
rc= my_process_stmt_result(stmt);
- assert(0 == rc);
+ DIE_UNLESS(0 == rc);
mysql_stmt_close(stmt);
@@ -11192,7 +11192,7 @@
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
rc= my_process_stmt_result(stmt);
- assert(0 == rc);
+ DIE_UNLESS(0 == rc);
}
mysql_stmt_close(stmt);
@@ -11255,7 +11255,7 @@
rc= mysql_stmt_execute(select_stmt);
check_execute(select_stmt, rc);
rowcount= (int)my_process_stmt_result(select_stmt);
- assert((i+1) == rowcount);
+ DIE_UNLESS((i+1) == rowcount);
}
mysql_stmt_close(insert_stmt);
mysql_stmt_close(select_stmt);
@@ -11296,7 +11296,7 @@
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
rc= my_process_stmt_result(stmt);
- assert(3 == rc);
+ DIE_UNLESS(3 == rc);
}
mysql_stmt_close(stmt);
@@ -11372,7 +11372,7 @@
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
rc= my_process_stmt_result(stmt);
- assert(1 == rc);
+ DIE_UNLESS(1 == rc);
mysql_stmt_close(stmt);
rc= mysql_query(mysql, "DROP VIEW v1");
@@ -12850,6 +12850,82 @@
DIE_UNLESS(!mysql_errno(mysql));
}
+/*
+ Bug #15518 - Reusing a stmt that has failed during prepare
+ does not clear error
+*/
+
+static void test_bug15518()
+{
+ MYSQL_STMT *stmt;
+ MYSQL* mysql1;
+ int rc;
+ myheader("test_bug15518");
+
+ mysql1= mysql_init(NULL);
+
+ if (!mysql_real_connect(mysql1, opt_host, opt_user, opt_password,
+ opt_db ? opt_db : "test", opt_port, opt_unix_socket,
+ CLIENT_MULTI_STATEMENTS))
+ {
+ fprintf(stderr, "Failed to connect to the database\n");
+ DIE_UNLESS(0);
+ }
+
+ stmt= mysql_stmt_init(mysql1);
+
+ /*
+ The prepare of foo should fail with errno 1064 since
+ it's not a valid query
+ */
+ rc= mysql_stmt_prepare(stmt, "foo", 3);
+ if (!opt_silent)
+ fprintf(stdout, "rc: %d, mysql_stmt_errno: %d, mysql_errno: %d\n",
+ rc, mysql_stmt_errno(stmt), mysql_errno(mysql1));
+ DIE_UNLESS(rc && mysql_stmt_errno(stmt) && mysql_errno(mysql1));
+
+ /*
+ Use the same stmt and reprepare with another query that
+ suceeds
+ */
+ rc= mysql_stmt_prepare(stmt, "SHOW STATUS", 12);
+ if (!opt_silent)
+ fprintf(stdout, "rc: %d, mysql_stmt_errno: %d, mysql_errno: %d\n",
+ rc, mysql_stmt_errno(stmt), mysql_errno(mysql1));
+ DIE_UNLESS(!rc || mysql_stmt_errno(stmt) || mysql_errno(mysql1));
+
+ mysql_stmt_close(stmt);
+ DIE_UNLESS(!mysql_errno(mysql1));
+
+ /*
+ part2, when connection to server has been closed
+ after first prepare
+ */
+ stmt= mysql_stmt_init(mysql1);
+ rc= mysql_stmt_prepare(stmt, "foo", 3);
+ if (!opt_silent)
+ fprintf(stdout, "rc: %d, mysql_stmt_errno: %d, mysql_errno: %d\n",
+ rc, mysql_stmt_errno(stmt), mysql_errno(mysql1));
+ DIE_UNLESS(rc && mysql_stmt_errno(stmt) && mysql_errno(mysql1));
+
+ /* Close connection to server */
+ mysql_close(mysql1);
+
+ /*
+ Use the same stmt and reprepare with another query that
+ suceeds. The prepare should fail with error 2013 since
+ connection to server has been closed.
+ */
+ rc= mysql_stmt_prepare(stmt, "SHOW STATUS", 12);
+ if (!opt_silent)
+ fprintf(stdout, "rc: %d, mysql_stmt_errno: %d\n",
+ rc, mysql_stmt_errno(stmt));
+ DIE_UNLESS(rc && mysql_stmt_errno(stmt));
+
+ mysql_stmt_close(stmt);
+ DIE_UNLESS(mysql_errno(mysql1));
+}
+
static void test_view_sp_list_fields()
{
@@ -15008,7 +15084,7 @@
}
else
{
- assert(0==1);
+ DIE_UNLESS(0==1);
}
}
@@ -15732,6 +15808,7 @@
{ "test_bug15752", test_bug15752 },
{ "test_bug21206", test_bug21206 },
{ "test_bug21726", test_bug21726 },
+ { "test_bug15518", test_bug15518 },
{ "test_bug23383", test_bug23383 },
{ "test_bug21635", test_bug21635 },
{ 0, 0 }
| Thread |
|---|
| • bk commit into 5.0 tree (jani:1.2368) | jani | 29 Jan |
