1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed failing test cases 'row.test' when running with --ps-protocol

Browse Source 
Simple optimzations done while reviewing code


client/mysqltest.c:
  Added options --enable-ps-warnings and --disable-ps-warnings
  (to fix failing test case)
mysql-test/t/row.test:
  Disable warnings that comes from 'parse' parth
sql/field.cc:
  Removed calls to is_null() in field functions.
  (Not needed as NULL handling is done on the level above fields)
  Indentation fixes
  Removed calls to alloca() as buffer needed was quite small.
sql/field.h:
  Indentation changes and comment fixes
sql/filesort.cc:
  Simple optimization during code review
sql/item.cc:
  Indentation fixes
  Removed some unnecessary tests (added DBUG_ASSERTS() instead)
sql/item_buff.cc:
  Indentation fixes
sql/my_decimal.cc:
  Indentation fixes
  Simple optimization
  Fixed compiler warning
sql/sql_update.cc:
  Removed unnessessary assignment
This commit is contained in:
unknown 2005-02-15 16:45:00 +02:00
parent 40ffce74eb
commit 67b16d202b
9 changed files with 116 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
client/mysqltest.c
View File

@ -253,6 +253,7 @@ VAR var_reg[10];
/*Perl/shell-like variable registers */
HASH var_hash;
my_bool disable_query_log=0, disable_result_log=0, disable_warnings=0;
my_bool disable_ps_warnings= 0;
my_bool disable_info= 1; /* By default off */
my_bool abort_on_error= 1;
@ -283,6 +284,7 @@ Q_ENABLE_RESULT_LOG, Q_DISABLE_RESULT_LOG,
Q_SERVER_START, Q_SERVER_STOP,Q_REQUIRE_MANAGER,
Q_WAIT_FOR_SLAVE_TO_STOP,
Q_ENABLE_WARNINGS, Q_DISABLE_WARNINGS,
Q_ENABLE_PS_WARNINGS, Q_DISABLE_PS_WARNINGS,
Q_ENABLE_INFO, Q_DISABLE_INFO,
Q_ENABLE_METADATA, Q_DISABLE_METADATA,
Q_EXEC, Q_DELIMITER,
@ -360,6 +362,8 @@ const char *command_names[]=
"wait_for_slave_to_stop",
"enable_warnings",
"disable_warnings",
"enable_ps_warnings",
"disable_ps_warnings",
"enable_info",
"disable_info",
"enable_metadata",
@ -3021,7 +3025,8 @@ static int run_query_stmt(MYSQL *mysql, struct st_query *q, int flags)
/* We may have got warnings already, collect them if any */
/* FIXME we only want this if the statement succeeds I think */
run_query_stmt_handle_warnings(mysql, ds);
if (!disable_ps_warnings)
run_query_stmt_handle_warnings(mysql, ds);
/*
No need to call mysql_stmt_bind_param() because we have no
@ -3711,6 +3716,8 @@ int main(int argc, char **argv)
case Q_DISABLE_RESULT_LOG: disable_result_log=1; break;
case Q_ENABLE_WARNINGS: disable_warnings=0; break;
case Q_DISABLE_WARNINGS: disable_warnings=1; break;
case Q_ENABLE_PS_WARNINGS: disable_ps_warnings=0; break;
case Q_DISABLE_PS_WARNINGS: disable_ps_warnings=1; break;
case Q_ENABLE_INFO: disable_info=0; break;
case Q_DISABLE_INFO: disable_info=1; break;
case Q_ENABLE_METADATA: display_metadata=1; break;

2
mysql-test/t/row.test
View File

@ -7,7 +7,9 @@ select (1,2,3) IN ((3,2,3), (1,2,3), (1,3,3));
select row(10,2,3) IN (row(3,2,3), row(1,2,3), row(1,3,3));
select row(1,2,3) IN (row(3,NULL,3), row(1,2,3), row(1,3,3));
select row(10,2,3) IN (row(3,NULL,3), row(1,2,3), row(1,3,3));
--disable_ps_warnings
select row('a',1.5,3) IN (row(1,2,3), row('a',1.5,3), row('a','a','a'));
--enable_ps_warnings
select row('a',0,3) IN (row(3,2,3), row('a','0','3'), row(1,3,3));
select row('a',0,3) IN (row(3,2,3), row('a','a','3'), row(1,3,3));
select row('a',1.5,3) IN (row(3,NULL,3), row('a',1.5,3), row(1,3,3));

58
sql/field.cc
View File

@ -572,8 +572,7 @@ my_decimal* Field_num::val_decimal(my_decimal *decimal_value)
{
DBUG_ASSERT(result_type() == INT_RESULT);
longlong nr= val_int();
if (!is_null())
int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
return decimal_value;
}
@ -605,7 +604,7 @@ void Field_num::make_field(Send_field *field)
d value for storing
NOTE
Field_str is the base class for fields like Field_date, and some
Field_str is the base class for fields like Field_enum, Field_date and some
similar. Some dates use fraction and also string value should be
converted to floating point value according our rules, so we use double
to store value of decimal in string
@ -629,8 +628,7 @@ my_decimal *Field_str::val_decimal(my_decimal *decimal_value)
{
DBUG_ASSERT(result_type() == INT_RESULT);
longlong nr= val_int();
if (is_null())
int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
return decimal_value;
}
@ -733,6 +731,7 @@ Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table,
return tmp;
}
/*
SYNOPSIS
Field::quote_data()
@ -749,44 +748,35 @@ Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table,
void Upon prepending/appending quotes on each side of variable
*/
bool Field::quote_data(String *unquoted_string)
{
char escaped_string[IO_SIZE];
char *unquoted_string_buffer= (char *)(unquoted_string->ptr());
uint need_quotes;
DBUG_ENTER("Field::quote_data");
// this is the same call that mysql_real_escape_string() calls
escape_string_for_mysql(&my_charset_bin, (char *)escaped_string,
unquoted_string->ptr(), unquoted_string->length());
if (is_null())
DBUG_RETURN(0);
need_quotes= needs_quotes();
if (need_quotes == 0)
{
DBUG_RETURN(0);
}
else
{
// reset string, then re-append with quotes and escaped values
unquoted_string->length(0);
if (unquoted_string->append("'"))
DBUG_RETURN(1);
if (unquoted_string->append((char *)escaped_string))
DBUG_RETURN(1);
if (unquoted_string->append("'"))
DBUG_RETURN(1);
}
//DBUG_PRINT("Field::quote_data",
// ("FINAL quote_flag %d unquoted_string %s escaped_string %s",
//needs_quotes, unquoted_string->c_ptr_quick(), escaped_string));
// reset string, then re-append with quotes and escaped values
unquoted_string->length(0);
if (unquoted_string->append('\''))
DBUG_RETURN(1);
if (unquoted_string->append((char *)escaped_string))
DBUG_RETURN(1);
if (unquoted_string->append('\''))
DBUG_RETURN(1);
DBUG_RETURN(0);
}
/*
Quote a field type if needed
@ -802,6 +792,7 @@ bool Field::quote_data(String *unquoted_string)
0 if value is of type NOT needing quotes
1 if value is of type needing quotes
*/
bool Field::needs_quotes(void)
{
DBUG_ENTER("Field::type_quote");
@ -840,9 +831,9 @@ bool Field::needs_quotes(void)
default: DBUG_RETURN(0);
}
DBUG_RETURN(0);
}
/****************************************************************************
Field_null, a field that always return NULL
****************************************************************************/
@ -4646,8 +4637,6 @@ String *Field_newdate::val_str(String *val_buffer,
bool Field_newdate::get_date(TIME *ltime,uint fuzzydate)
{
if (is_null())
return 1;
uint32 tmp=(uint32) uint3korr(ptr);
ltime->day= tmp & 31;
ltime->month= (tmp >> 5) & 15;
@ -5058,17 +5047,16 @@ int Field_string::store(longlong nr)
return Field_string::store(buff,(uint)l,cs);
}
int Field_longstr::store_decimal(const my_decimal *d)
{
uint buf_size= my_decimal_string_length(d);
char *buff= (char *)my_alloca(buf_size);
String str(buff, buf_size, &my_charset_bin);
char buff[DECIMAL_MAX_STR_LENGTH+1];
String str(buff, sizeof(buff), &my_charset_bin);
my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
int result= store(str.ptr(), str.length(), str.charset());
my_afree(buff);
return result;
return store(str.ptr(), str.length(), str.charset());
}
double Field_string::val_real(void)
{
int not_used;

8
sql/field.h
View File

@ -367,7 +367,9 @@ public:
my_decimal *val_decimal(my_decimal *);
};
/* base class for Item_string, Item_valstring, Item_blob */
/* base class for Field_string, Field_varstring and Field_blob */
class Field_longstr :public Field_str
{
public:
@ -1181,7 +1183,9 @@ public:
bool has_charset(void) const
{ return charset() == &my_charset_bin ? FALSE : TRUE; }
field_cast_enum field_cast_type() { return FIELD_CAST_BLOB; }
uint32 max_length();};
uint32 max_length();
};
#ifdef HAVE_SPATIAL
class Field_geom :public Field_blob {

65
sql/filesort.cc
View File

@ -619,20 +619,21 @@ static void make_sortkey(register SORTPARAM *param,
else
{ // Item
Item *item=sort_field->item;
maybe_null= item->maybe_null;
switch (sort_field->result_type) {
case STRING_RESULT:
{
CHARSET_INFO *cs=item->collation.collation;
char fill_char= ((cs->state & MY_CS_BINSORT) ? (char) 0 : ' ');
if ((maybe_null=item->maybe_null))
if (maybe_null)
*to++=1;
/* All item->str() to use some extra byte for end null.. */
String tmp((char*) to,sort_field->length+4,cs);
String *res=item->val_str(&tmp);
if (!res)
{
if (item->maybe_null)
if (maybe_null)
bzero((char*) to-1,sort_field->length+1);
else
{
@ -672,20 +673,22 @@ static void make_sortkey(register SORTPARAM *param,
case INT_RESULT:
{
longlong value=item->val_int();
if ((maybe_null=item->maybe_null))
if (maybe_null)
{
*to++=1; /* purecov: inspected */
if (item->null_value)
{
if (item->maybe_null)
bzero((char*) to-1,sort_field->length+1);
else
{
DBUG_PRINT("warning",
("Got null on something that shouldn't be null"));
bzero((char*) to,sort_field->length);
}
break;
}
if (item->null_value)
{
if (maybe_null)
bzero((char*) to-1,sort_field->length+1);
else
{
DBUG_PRINT("warning",
("Got null on something that shouldn't be null"));
bzero((char*) to,sort_field->length);
}
break;
}
}
#if SIZEOF_LONG_LONG > 4
to[7]= (uchar) value;
to[6]= (uchar) (value >> 8);
@ -706,14 +709,16 @@ static void make_sortkey(register SORTPARAM *param,
case DECIMAL_RESULT:
{
my_decimal dec_buf, *dec_val= item->val_decimal(&dec_buf);
if ((maybe_null=item->null_value))
{
bzero((char*)to, sort_field->length+1);
to++;
break;
}
if ((maybe_null=item->maybe_null))
if (maybe_null)
{
if (item->null_value)
{
bzero((char*)to, sort_field->length+1);
to++;
break;
}
*to++=1;
}
my_decimal2binary(E_DEC_FATAL_ERROR, dec_val, (byte*)to,
item->max_length - (item->decimals ? 1:0),
item->decimals);
@ -722,14 +727,16 @@ static void make_sortkey(register SORTPARAM *param,
case REAL_RESULT:
{
double value= item->val_real();
if ((maybe_null=item->null_value))
{
bzero((char*) to,sort_field->length+1);
to++;
break;
}
if ((maybe_null=item->maybe_null))
if (maybe_null)
{
if (item->null_value)
{
bzero((char*) to,sort_field->length+1);
to++;
break;
}
*to++=1;
}
change_double_for_sort(value,(byte*) to);
break;
}

55
sql/item.cc
View File

@ -48,10 +48,10 @@ void item_init(void)
/*
TODO: make this functions class dependent
*/
bool Item::val_bool()
{
switch(result_type())
{
switch(result_type()) {
case INT_RESULT:
return val_int();
case DECIMAL_RESULT:
@ -68,6 +68,7 @@ bool Item::val_bool()
case ROW_RESULT:
default:
DBUG_ASSERT(0);
return 0; // Wrong (but safe)
}
}
@ -991,8 +992,7 @@ bool Item_field::val_bool_result()
{
if ((null_value= result_field->is_null()))
return FALSE;
switch (result_field->result_type())
{
switch (result_field->result_type()) {
case INT_RESULT:
return result_field->val_int();
case DECIMAL_RESULT:
@ -1060,8 +1060,9 @@ Item *Item_field::get_tmp_table_item(THD *thd)
/*
Create an item from a string we KNOW points to a valid longlong/ulonglong
end \0 terminated number string
Create an item from a string we KNOW points to a valid longlong
end \0 terminated number string.
This is always 'signed'. Unsigned values are created with Item_uint()
*/
Item_int::Item_int(const char *str_arg, uint length)
@ -1071,7 +1072,6 @@ Item_int::Item_int(const char *str_arg, uint length)
value= my_strtoll10(str_arg, &end_ptr, &error);
max_length= (uint) (end_ptr - str_arg);
name= (char*) str_arg;
unsigned_flag= value > 0;
fixed= 1;
}
@ -2436,8 +2436,8 @@ bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **reference)
rf is Item_ref => never substitute other items (in this case)
during fix_fields() => we can use rf after fix_fields()
*/
if (!rf->fixed &&
rf->fix_fields(thd, tables, reference) || rf->check_cols(1))
DBUG_ASSERT(!rf->fixed); // Assured by Item_ref()
if (rf->fix_fields(thd, tables, reference) || rf->check_cols(1))
return TRUE;
mark_as_dependent(thd, last, current_sel, rf);
@ -2458,8 +2458,8 @@ bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **reference)
rf is Item_ref => never substitute other items (in this case)
during fix_fields() => we can use rf after fix_fields()
*/
return (!rf->fixed &&
rf->fix_fields(thd, tables, reference) || rf->check_cols(1));
DBUG_ASSERT(!rf->fixed); // Assured by Item_ref()
return (rf->fix_fields(thd, tables, reference) || rf->check_cols(1));
}
}
}
@ -2706,8 +2706,7 @@ void Item_empty_string::make_field(Send_field *tmp_field)
enum_field_types Item::field_type() const
{
switch (result_type())
{
switch (result_type()) {
case STRING_RESULT: return MYSQL_TYPE_VARCHAR;
case INT_RESULT: return FIELD_TYPE_LONGLONG;
case DECIMAL_RESULT: return FIELD_TYPE_NEWDECIMAL;
@ -2715,8 +2714,8 @@ enum_field_types Item::field_type() const
case ROW_RESULT:
default:
DBUG_ASSERT(0);
return FIELD_TYPE_VAR_STRING;
};
return MYSQL_TYPE_VARCHAR;
}
}
@ -3662,18 +3661,17 @@ bool Item_ref::val_bool_result()
{
if ((null_value= result_field->is_null()))
return 0;
switch (result_field->result_type())
{
switch (result_field->result_type()) {
case INT_RESULT:
return result_field->val_int();
case DECIMAL_RESULT:
{
my_decimal decimal_value;
my_decimal *val= result_field->val_decimal(&decimal_value);
if (val)
return !my_decimal_is_zero(val);
return 0;
}
{
my_decimal decimal_value;
my_decimal *val= result_field->val_decimal(&decimal_value);
if (val)
return !my_decimal_is_zero(val);
return 0;
}
case REAL_RESULT:
case STRING_RESULT:
return result_field->val_real() != 0.0;
@ -4049,8 +4047,7 @@ void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
item->result_type());
char *name=item->name; // Alloced by sql_alloc
switch (res_type)
{
switch (res_type) {
case STRING_RESULT:
{
char buff[MAX_FIELD_WIDTH];
@ -4146,8 +4143,7 @@ bool field_is_equal_to_item(Field *field,Item *item)
Item_cache* Item_cache::get_cache(Item_result type)
{
switch (type)
{
switch (type) {
case INT_RESULT:
return new Item_cache_int();
case REAL_RESULT:
@ -4617,8 +4613,7 @@ uint32 Item_type_holder::real_length(Item *item)
if (item->type() == Item::FIELD_ITEM)
return ((Item_field *)item)->max_disp_length();
switch (item->result_type())
{
switch (item->result_type()) {
case STRING_RESULT:
case DECIMAL_RESULT:
return item->max_length;

3
sql/item_buff.cc
View File

@ -28,8 +28,7 @@ Item_buff *new_Item_buff(Item *item)
if (item->type() == Item::FIELD_ITEM &&
!(((Item_field *) item)->field->flags & BLOB_FLAG))
return new Item_field_buff((Item_field *) item);
switch (item->result_type())
{
switch (item->result_type()) {
case STRING_RESULT:
return new Item_str_buff((Item_field *) item);
case INT_RESULT:

28
sql/my_decimal.cc
View File

@ -23,16 +23,18 @@
decimal_operation_results()
result decimal library return code (E_DEC_* see include/decimal.h)
return
TODO
Fix error messages
RETURN
result
*/
int decimal_operation_results(int result)
{
switch (result)
{
switch (result) {
case E_DEC_OK:
break;
//TODO: fix error messages
case E_DEC_TRUNCATED:
push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
WARN_DATA_TRUNCATED, ER(WARN_DATA_TRUNCATED),
@ -78,20 +80,18 @@ int decimal_operation_results(int result)
*/
int my_decimal2string(uint mask, const my_decimal *d,
int fixed_prec, int fixed_dec,
char filler, String *str)
int fixed_prec, int fixed_dec,
char filler, String *str)
{
int length= (fixed_prec ? (fixed_prec + 1) : my_decimal_string_length(d));
int result;
if (str->alloc(length))
return check_result(mask, E_DEC_OOM);
char *sptr= (char *)str->ptr();
int res= decimal2string((decimal *)d, sptr,
&length, fixed_prec, fixed_dec,
filler);
result= check_result(mask, res);
return check_result(mask, E_DEC_OOM);
result= decimal2string((decimal*) d, (char*) str->ptr(),
&length, fixed_prec, fixed_dec,
filler);
str->length(length);
return result;
return check_result(mask, result);
}
@ -171,7 +171,7 @@ int str2my_decimal(uint mask, const char *from, uint length,
}
my_decimal_set_zero(decimal_value);
err= string2decimal((char *)from, (decimal *)decimal_value, &end);
if ((end-from) != length && !err)
if ((uint) (end-from) != length && !err)
err= E_DEC_TRUNCATED;
check_result(mask, err);
return err;

4
sql/sql_update.cc
View File

@ -264,10 +264,8 @@ int mysql_update(THD *thd,
else if ((used_index=table->file->key_used_on_scan) < MAX_KEY)
used_key_is_modified=check_if_key_used(table, used_index, fields);
else
{
used_key_is_modified=0;
used_index= MAX_KEY;
}
if (used_key_is_modified || order)
{
/*