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

Merge laptop.sanja.is.com.ua:/home/bell/mysql/bk/mysql-4.1

Browse Source 
into laptop.sanja.is.com.ua:/home/bell/mysql/bk/work-collation-4.1
This commit is contained in:
bell@laptop.sanja.is.com.ua 2003-08-26 23:32:20 +03:00
commit 8b8b984da0
9 changed files with 81 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
mysql-test/r/olap.result
View File

@ -254,3 +254,18 @@ ERROR 42000: This version of MySQL doesn't yet support 'CUBE'
select product, country_id , year, sum(profit) from t1 group by product, country_id, year with cube union all select product, country_id , year, sum(profit) from t1 group by product, country_id, year with rollup; select product, country_id , year, sum(profit) from t1 group by product, country_id, year with cube union all select product, country_id , year, sum(profit) from t1 group by product, country_id, year with rollup;
ERROR 42000: This version of MySQL doesn't yet support 'CUBE' ERROR 42000: This version of MySQL doesn't yet support 'CUBE'
drop table t1,t2; drop table t1,t2;
CREATE TABLE t1 (i int);
INSERT INTO t1 VALUES(100);
CREATE TABLE t2 (i int);
INSERT INTO t2 VALUES (100),(200);
SELECT i, COUNT(*) FROM t1 GROUP BY i WITH ROLLUP;
i COUNT(*)
100 1
NULL 1
SELECT t1.i, t2.i, COUNT(*) FROM t1,t2 GROUP BY t1.i,t2.i WITH ROLLUP;
i i COUNT(*)
100 100 1
100 200 1
100 NULL 2
NULL NULL 2
drop table t1,t2;

4
mysql-test/t/loaddata.test
View File

@ -15,7 +15,3 @@ truncate table t1;
load data infile '../../std_data/loaddata1.dat' into table t1 fields terminated by ',' LINES STARTING BY ',' (b,c,d); load data infile '../../std_data/loaddata1.dat' into table t1 fields terminated by ',' LINES STARTING BY ',' (b,c,d);
SELECT * from t1; SELECT * from t1;
drop table t1; drop table t1;

11
mysql-test/t/olap.test
View File

@ -77,3 +77,14 @@ select product, country_id , year, sum(profit) from t1 group by product, country
drop table t1,t2; drop table t1,t2;
#
# Test bug with const tables
#
CREATE TABLE t1 (i int);
INSERT INTO t1 VALUES(100);
CREATE TABLE t2 (i int);
INSERT INTO t2 VALUES (100),(200);
SELECT i, COUNT(*) FROM t1 GROUP BY i WITH ROLLUP;
SELECT t1.i, t2.i, COUNT(*) FROM t1,t2 GROUP BY t1.i,t2.i WITH ROLLUP;
drop table t1,t2;

34
mysys/my_malloc.c
View File

@ -24,26 +24,26 @@
/* My memory allocator */ /* My memory allocator */
gptr my_malloc(unsigned int Size, myf MyFlags) gptr my_malloc(unsigned int size, myf my_flags)
{ {
gptr point; gptr point;
DBUG_ENTER("my_malloc"); DBUG_ENTER("my_malloc");
DBUG_PRINT("my",("Size: %u MyFlags: %d",Size, MyFlags)); DBUG_PRINT("my",("size: %u my_flags: %d",size, my_flags));
if (!Size) if (!size)
Size=1; /* Safety */ size=1; /* Safety */
if ((point = (char*)malloc(Size)) == NULL) if ((point = (char*)malloc(size)) == NULL)
{ {
my_errno=errno; my_errno=errno;
if (MyFlags & MY_FAE) if (my_flags & MY_FAE)
error_handler_hook=fatal_error_handler_hook; error_handler_hook=fatal_error_handler_hook;
if (MyFlags & (MY_FAE+MY_WME)) if (my_flags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_WAITTANG),Size); my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_WAITTANG),size);
if (MyFlags & MY_FAE) if (my_flags & MY_FAE)
exit(1); exit(1);
} }
else if (MyFlags & MY_ZEROFILL) else if (my_flags & MY_ZEROFILL)
bzero(point,Size); bzero(point,size);
DBUG_PRINT("exit",("ptr: %lx",point)); DBUG_PRINT("exit",("ptr: %lx",point));
DBUG_RETURN(point); DBUG_RETURN(point);
} /* my_malloc */ } /* my_malloc */
@ -64,29 +64,29 @@ void my_no_flags_free(gptr ptr)
/* malloc and copy */ /* malloc and copy */
gptr my_memdup(const byte *from, uint length, myf MyFlags) gptr my_memdup(const byte *from, uint length, myf my_flags)
{ {
gptr ptr; gptr ptr;
if ((ptr=my_malloc(length,MyFlags)) != 0) if ((ptr=my_malloc(length,my_flags)) != 0)
memcpy((byte*) ptr, (byte*) from,(size_t) length); memcpy((byte*) ptr, (byte*) from,(size_t) length);
return(ptr); return(ptr);
} }
char *my_strdup(const char *from, myf MyFlags) char *my_strdup(const char *from, myf my_flags)
{ {
gptr ptr; gptr ptr;
uint length=(uint) strlen(from)+1; uint length=(uint) strlen(from)+1;
if ((ptr=my_malloc(length,MyFlags)) != 0) if ((ptr=my_malloc(length,my_flags)) != 0)
memcpy((byte*) ptr, (byte*) from,(size_t) length); memcpy((byte*) ptr, (byte*) from,(size_t) length);
return((my_string) ptr); return((my_string) ptr);
} }
char *my_strdup_with_length(const byte *from, uint length, myf MyFlags) char *my_strdup_with_length(const byte *from, uint length, myf my_flags)
{ {
gptr ptr; gptr ptr;
if ((ptr=my_malloc(length+1,MyFlags)) != 0) if ((ptr=my_malloc(length+1,my_flags)) != 0)
{ {
memcpy((byte*) ptr, (byte*) from,(size_t) length); memcpy((byte*) ptr, (byte*) from,(size_t) length);
((char*) ptr)[length]=0; ((char*) ptr)[length]=0;

33
mysys/my_realloc.c
View File

@ -23,40 +23,41 @@
/* My memory re allocator */ /* My memory re allocator */
gptr my_realloc(gptr oldpoint, uint Size, myf MyFlags) gptr my_realloc(gptr oldpoint, uint size, myf my_flags)
{ {
gptr point; gptr point;
DBUG_ENTER("my_realloc"); DBUG_ENTER("my_realloc");
DBUG_PRINT("my",("ptr: %lx Size: %u MyFlags: %d",oldpoint, Size, MyFlags)); DBUG_PRINT("my",("ptr: %lx size: %u my_flags: %d",oldpoint, size,
my_flags));
if (!oldpoint && (MyFlags & MY_ALLOW_ZERO_PTR)) if (!oldpoint && (my_flags & MY_ALLOW_ZERO_PTR))
DBUG_RETURN(my_malloc(Size,MyFlags)); DBUG_RETURN(my_malloc(size,my_flags));
#ifdef USE_HALLOC #ifdef USE_HALLOC
if (!(point = malloc(Size))) if (!(point = malloc(size)))
{ {
if (MyFlags & MY_FREE_ON_ERROR) if (my_flags & MY_FREE_ON_ERROR)
my_free(oldpoint,MyFlags); my_free(oldpoint,my_flags);
if (MyFlags & MY_HOLD_ON_ERROR) if (my_flags & MY_HOLD_ON_ERROR)
DBUG_RETURN(oldpoint); DBUG_RETURN(oldpoint);
my_errno=errno; my_errno=errno;
if (MyFlags & MY_FAE+MY_WME) if (my_flags & MY_FAE+MY_WME)
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_WAITTANG),Size); my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_WAITTANG),size);
} }
else else
{ {
memcpy(point,oldpoint,Size); memcpy(point,oldpoint,size);
free(oldpoint); free(oldpoint);
} }
#else #else
if ((point = (char*)realloc(oldpoint,Size)) == NULL) if ((point = (char*)realloc(oldpoint,size)) == NULL)
{ {
if (MyFlags & MY_FREE_ON_ERROR) if (my_flags & MY_FREE_ON_ERROR)
my_free(oldpoint,MyFLAGS); my_free(oldpoint,MyFLAGS);
if (MyFlags & MY_HOLD_ON_ERROR) if (my_flags & MY_HOLD_ON_ERROR)
DBUG_RETURN(oldpoint); DBUG_RETURN(oldpoint);
my_errno=errno; my_errno=errno;
if (MyFlags & (MY_FAE+MY_WME)) if (my_flags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_WAITTANG), Size); my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_WAITTANG), size);
} }
#endif #endif
DBUG_PRINT("exit",("ptr: %lx",point)); DBUG_PRINT("exit",("ptr: %lx",point));

2
sql-common/client.c
View File

@ -587,7 +587,7 @@ net_safe_read(MYSQL *mysql)
DBUG_PRINT("error",("Wrong connection or packet. fd: %s len: %d", DBUG_PRINT("error",("Wrong connection or packet. fd: %s len: %d",
vio_description(net->vio),len)); vio_description(net->vio),len));
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
if (socket_errno == SOCKET_EINTR) if (vio_errno(net->vio) == SOCKET_EINTR)
return (packet_error); return (packet_error);
#endif /*MYSQL_SERVER*/ #endif /*MYSQL_SERVER*/
end_server(mysql); end_server(mysql);

25
sql/sql_select.cc
View File

@ -117,10 +117,8 @@ static Item* part_of_refkey(TABLE *form,Field *field);
static uint find_shortest_key(TABLE *table, key_map usable_keys); static uint find_shortest_key(TABLE *table, key_map usable_keys);
static bool test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order, static bool test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,
ha_rows select_limit, bool no_changes); ha_rows select_limit, bool no_changes);
static int create_sort_index(THD *thd, JOIN_TAB *tab,ORDER *order, static int create_sort_index(THD *thd, JOIN *join, ORDER *order,
ha_rows filesort_limit, ha_rows select_limit); ha_rows filesort_limit, ha_rows select_limit);
static int create_sort_index(THD *thd, JOIN_TAB *tab,ORDER *order,
ha_rows select_limit);
static int remove_duplicates(JOIN *join,TABLE *entry,List<Item> &fields, static int remove_duplicates(JOIN *join,TABLE *entry,List<Item> &fields,
Item *having); Item *having);
static int remove_dup_with_compare(THD *thd, TABLE *entry, Field **field, static int remove_dup_with_compare(THD *thd, TABLE *entry, Field **field,
@ -916,7 +914,7 @@ JOIN::optimize()
{ {
DBUG_PRINT("info",("Sorting for group")); DBUG_PRINT("info",("Sorting for group"));
thd->proc_info="Sorting for group"; thd->proc_info="Sorting for group";
if (create_sort_index(thd, &join_tab[const_tables], group_list, if (create_sort_index(thd, this, group_list,
HA_POS_ERROR, HA_POS_ERROR) || HA_POS_ERROR, HA_POS_ERROR) ||
alloc_group_fields(this, group_list) || alloc_group_fields(this, group_list) ||
make_sum_func_list(all_fields, fields_list, 1)) make_sum_func_list(all_fields, fields_list, 1))
@ -931,7 +929,7 @@ JOIN::optimize()
{ {
DBUG_PRINT("info",("Sorting for order")); DBUG_PRINT("info",("Sorting for order"));
thd->proc_info="Sorting for order"; thd->proc_info="Sorting for order";
if (create_sort_index(thd, &join_tab[const_tables], order, if (create_sort_index(thd, this, order,
HA_POS_ERROR, HA_POS_ERROR)) HA_POS_ERROR, HA_POS_ERROR))
DBUG_RETURN(1); DBUG_RETURN(1);
order=0; order=0;
@ -1235,7 +1233,7 @@ JOIN::exec()
if (curr_join->group_list) if (curr_join->group_list)
{ {
thd->proc_info= "Creating sort index"; thd->proc_info= "Creating sort index";
if (create_sort_index(thd, curr_join->join_tab, curr_join->group_list, if (create_sort_index(thd, curr_join, curr_join->group_list,
HA_POS_ERROR, HA_POS_ERROR) || HA_POS_ERROR, HA_POS_ERROR) ||
make_group_fields(this, curr_join)) make_group_fields(this, curr_join))
{ {
@ -1416,7 +1414,7 @@ JOIN::exec()
} }
} }
} }
if (create_sort_index(thd, &curr_join->join_tab[curr_join->const_tables], if (create_sort_index(thd, curr_join,
curr_join->group_list ? curr_join->group_list ?
curr_join->group_list : curr_join->order, curr_join->group_list : curr_join->order,
curr_join->select_limit, unit->select_limit_cnt)) curr_join->select_limit, unit->select_limit_cnt))
@ -6770,16 +6768,23 @@ test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,ha_rows select_limit,
*/ */
static int static int
create_sort_index(THD *thd, JOIN_TAB *tab, ORDER *order, create_sort_index(THD *thd, JOIN *join, ORDER *order,
ha_rows filesort_limit, ha_rows select_limit) ha_rows filesort_limit, ha_rows select_limit)
{ {
SORT_FIELD *sortorder; SORT_FIELD *sortorder;
uint length; uint length;
ha_rows examined_rows; ha_rows examined_rows;
TABLE *table=tab->table; TABLE *table;
SQL_SELECT *select=tab->select; SQL_SELECT *select;
JOIN_TAB *tab;
DBUG_ENTER("create_sort_index"); DBUG_ENTER("create_sort_index");
if (join->tables == join->const_tables)
DBUG_RETURN(0); // One row, no need to sort
tab= join->join_tab + join->const_tables;
table= tab->table;
select= tab->select;
if (test_if_skip_sort_order(tab,order,select_limit,0)) if (test_if_skip_sort_order(tab,order,select_limit,0))
DBUG_RETURN(0); DBUG_RETURN(0);
if (!(sortorder=make_unireg_sortorder(order,&length))) if (!(sortorder=make_unireg_sortorder(order,&length)))

3
sql/sql_yacc.yy
View File

@ -4380,6 +4380,7 @@ keyword:
| BOOL_SYM {} | BOOL_SYM {}
| BOOLEAN_SYM {} | BOOLEAN_SYM {}
| BYTE_SYM {} | BYTE_SYM {}
| BTREE_SYM {}
| CACHE_SYM {} | CACHE_SYM {}
| CHANGED {} | CHANGED {}
| CHARSET {} | CHARSET {}
@ -4425,6 +4426,7 @@ keyword:
| GRANTS {} | GRANTS {}
| GLOBAL_SYM {} | GLOBAL_SYM {}
| HANDLER_SYM {} | HANDLER_SYM {}
| HASH_SYM {}
| HEAP_SYM {} | HEAP_SYM {}
| HELP_SYM {} | HELP_SYM {}
| HOSTS_SYM {} | HOSTS_SYM {}
@ -4507,6 +4509,7 @@ keyword:
| ROWS_SYM {} | ROWS_SYM {}
| ROW_FORMAT_SYM {} | ROW_FORMAT_SYM {}
| ROW_SYM {} | ROW_SYM {}
| RTREE_SYM {}
| SAVEPOINT_SYM {} | SAVEPOINT_SYM {}
| SECOND_SYM {} | SECOND_SYM {}
| SERIAL_SYM {} | SERIAL_SYM {}

7
sql/table.cc
View File

@ -1207,17 +1207,14 @@ bool get_field(MEM_ROOT *mem, Field *field, String *res)
char *get_field(MEM_ROOT *mem, Field *field) char *get_field(MEM_ROOT *mem, Field *field)
{ {
char buff[MAX_FIELD_WIDTH], *to; char buff[MAX_FIELD_WIDTH];
String str(buff,sizeof(buff),&my_charset_bin); String str(buff,sizeof(buff),&my_charset_bin);
uint length; uint length;
field->val_str(&str,&str); field->val_str(&str,&str);
if (!(length= str.length())) if (!(length= str.length()))
return NullS; return NullS;
to= (char*) alloc_root(mem,length+1); return strmake_root(mem, str.ptr(), length);
memcpy(to, str.ptr(), (uint) length);
to[length]=0;
return to;
} }