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

Merge mysql.com:/home/pz/mysql/mysql-4.1-root

Browse Source 
into mysql.com:/home/pz/mysql/mysql-4.1


sql/sql_yacc.yy:
  Auto merged
This commit is contained in:
unknown 2002-10-31 13:02:29 +03:00
commit a6a8ce2842
15 changed files with 2153 additions and 1255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
.bzrignore
View File

@ -75,6 +75,7 @@ Makefile.in'
PENDING/*
TAGS
aclocal.m4
autom4te.cache/*
bdb/README
bdb/btree/btree_auto.c
bdb/build_unix/*
@ -192,6 +193,7 @@ config.h.in
config.log
config.status
configure
configure.lineno
core
db-*.*.*
dbug/user.t
@ -209,10 +211,13 @@ include/my_config.h
include/my_global.h
include/mysql_version.h
include/widec.h
innobase/autom4te.cache/*
innobase/configure.lineno
innobase/conftest.s1
innobase/conftest.subs
innobase/ib_config.h
innobase/ib_config.h.in
innobase/stamp-h1
isam/isamchk
isam/isamlog
isam/pack_isam
@ -302,6 +307,7 @@ libmysqld/sql_db.cc
libmysqld/sql_delete.cc
libmysqld/sql_do.cc
libmysqld/sql_handler.cc
libmysqld/sql_help.cc
libmysqld/sql_insert.cc
libmysqld/sql_lex.cc
libmysqld/sql_list.cc
@ -361,6 +367,8 @@ myisam/myisamchk
myisam/myisamlog
myisam/myisampack
myisam/rt_test
myisam/rt_test.MYD
myisam/rt_test.MYI
myisam/sp_test
myisam/test1.MYD
myisam/test1.MYI
@ -405,6 +413,8 @@ repl-tests/test-repl/foo-dump-slave.master.
repl-tests/test-repl/sum-wlen-slave.master.
repl-tests/test-repl/sum-wlen-slave.master.re
repl-tests/test-repl/sum-wlen-slave.master.reje
scripts/fill_func_tables
scripts/fill_func_tables.sql
scripts/make_binary_distribution
scripts/msql2mysql
scripts/mysql_config
@ -474,8 +484,11 @@ sql/sql_select.cc.orig
sql/sql_yacc.cc
sql/sql_yacc.h
sql/sql_yacc.yy.orig
sql_error.cc
sql_prepare.cc
stamp-h
stamp-h.in
stamp-h1
strings/conf_to_src
strings/ctype_autoconf.c
strings/ctype_extra_sources.c
@ -503,13 +516,3 @@ vio/test-ssl
vio/test-sslclient
vio/test-sslserver
vio/viotest-ssl
sql_error.cc
sql_prepare.cc
autom4te.cache/*
innobase/autom4te.cache/*
configure.lineno
innobase/configure.lineno
innobase/stamp-h1
myisam/rt_test.MYD
myisam/rt_test.MYI
stamp-h1

1
BitKeeper/etc/config
View File

@ -69,4 +69,5 @@ pager:
hours:
[serg:]checkout:get
[arjen:]checkout:get
[nick:]checkout:get
checkout:edit

4
include/thr_lock.h
View File

@ -74,6 +74,7 @@ typedef struct st_thr_lock_data {
enum thr_lock_type type;
ulong thread_id;
void *status_param; /* Param to status functions */
void *debug_print_param;
} THR_LOCK_DATA;
struct st_lock_list {
@ -97,6 +98,9 @@ typedef struct st_thr_lock {
} THR_LOCK;
extern LIST *thr_lock_thread_list;
extern pthread_mutex_t THR_LOCK_lock;
my_bool init_thr_lock(void); /* Must be called once/thread */
void thr_lock_init(THR_LOCK *lock);
void thr_lock_delete(THR_LOCK *lock);

6
mysql-test/r/derived.result
View File

@ -18,3 +18,9 @@ a y
3 3
3 3
drop table if exists t1.t2,t3;
select * from (select 1);
1
1
select a from (select 1 as a);
a
1

BIN
mysql-test/std_data/master-bin.001
View File

Binary file not shown.

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

@ -9,3 +9,5 @@ CREATE TABLE t3 (a int not null, b char (10) not null);
insert into t3 values (3,'f'),(4,'y'),(5,'z'),(6,'c');
select t1.a,t4.y from t1,(select t2.a as y from t2,(select t3.b from t3 where t3.a>3) as t5 where t2.b=t5.b) as t4 where t1.a = t4.y;
drop table if exists t1.t2,t3;
select * from (select 1);
select a from (select 1 as a);

8
mysys/thr_lock.c
View File

@ -91,7 +91,7 @@ enum thr_lock_type thr_upgraded_concurrent_insert_lock = TL_WRITE;
#define MAX_LOCKS 100
static LIST *thread_list; /* List of threads in use */
LIST *thr_lock_thread_list; /* List of threads in use */
ulong max_write_lock_count= ~(ulong) 0L;
static inline pthread_cond_t *get_cond(void)
@ -307,7 +307,7 @@ void thr_lock_init(THR_LOCK *lock)
pthread_mutex_lock(&THR_LOCK_lock); /* Add to locks in use */
lock->list.data=(void*) lock;
thread_list=list_add(thread_list,&lock->list);
thr_lock_thread_list=list_add(thr_lock_thread_list,&lock->list);
pthread_mutex_unlock(&THR_LOCK_lock);
DBUG_VOID_RETURN;
}
@ -318,7 +318,7 @@ void thr_lock_delete(THR_LOCK *lock)
DBUG_ENTER("thr_lock_delete");
VOID(pthread_mutex_destroy(&lock->mutex));
pthread_mutex_lock(&THR_LOCK_lock);
thread_list=list_delete(thread_list,&lock->list);
thr_lock_thread_list=list_delete(thr_lock_thread_list,&lock->list);
pthread_mutex_unlock(&THR_LOCK_lock);
DBUG_VOID_RETURN;
}
@ -1061,7 +1061,7 @@ void thr_print_locks(void)
pthread_mutex_lock(&THR_LOCK_lock);
puts("Current locks:");
for (list=thread_list ; list && count++ < MAX_THREADS ; list=rest(list))
for (list=thr_lock_thread_list ; list && count++ < MAX_THREADS ; list=rest(list))
{
THR_LOCK *lock=(THR_LOCK*) list->data;
VOID(pthread_mutex_lock(&lock->mutex));

11
sql/lock.cc
View File

@ -69,6 +69,12 @@ TODO:
#include "mysql_priv.h"
#include <hash.h>
#include <assert.h>
#include <ha_myisammrg.h>
#ifndef MASTER
#include "../srclib/myisammrg/myrg_def.h"
#else
#include "../myisammrg/myrg_def.h"
#endif
extern HASH open_cache;
@ -154,6 +160,7 @@ retry:
sql_lock=0;
}
}
thd->lock_time();
DBUG_RETURN (sql_lock);
}
@ -410,8 +417,12 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count,
return 0;
}
}
THR_LOCK_DATA **org_locks = locks;
locks=table->file->store_lock(thd, locks, get_old_locks ? TL_IGNORE :
lock_type);
if (locks)
for ( ; org_locks != locks ; org_locks++)
(*org_locks)->debug_print_param= (void *) table;
}
return sql_lock;
}

2995
sql/log_event.cc
View File

File diff suppressed because it is too large Load Diff

107
sql/log_event.h
View File

@ -54,6 +54,11 @@
#define LINE_START_EMPTY 0x8
#define ESCAPED_EMPTY 0x10
/*****************************************************************************
old_sql_ex struct
****************************************************************************/
struct old_sql_ex
{
char field_term;
@ -67,6 +72,11 @@ struct old_sql_ex
#define NUM_LOAD_DELIM_STRS 5
/*****************************************************************************
sql_ex_info struct
****************************************************************************/
struct sql_ex_info
{
char* field_term;
@ -99,13 +109,19 @@ struct sql_ex_info
}
};
/*
Binary log consists of events. Each event has a fixed length header,
followed by possibly variable ( depending on the type of event) length
data body. The data body consists of an optional fixed length segment
(post-header), and an optional variable length segment. See #defines and
comments below for the format specifics
*/
/*****************************************************************************
MySQL Binary Log
This log consists of events. Each event has a fixed-length header,
possibly followed by a variable length data body.
The data body consists of an optional fixed length segment (post-header)
and an optional variable length segment.
See the #defines below for the format specifics.
****************************************************************************/
/* event-specific post-header sizes */
#define LOG_EVENT_HEADER_LEN 19
@ -221,6 +237,13 @@ class THD;
struct st_relay_log_info;
/*****************************************************************************
Log_event class
This is the abstract base class for binary log events.
****************************************************************************/
class Log_event
{
public:
@ -303,6 +326,13 @@ public:
};
/*****************************************************************************
Query Log Event class
Logs SQL queries
****************************************************************************/
class Query_log_event: public Log_event
{
protected:
@ -355,6 +385,11 @@ public:
};
/*****************************************************************************
Slave Log Event class
****************************************************************************/
class Slave_log_event: public Log_event
{
protected:
@ -384,6 +419,12 @@ public:
int write_data(IO_CACHE* file );
};
/*****************************************************************************
Load Log Event class
****************************************************************************/
class Load_log_event: public Log_event
{
protected:
@ -446,6 +487,11 @@ public:
extern char server_version[SERVER_VERSION_LENGTH];
/*****************************************************************************
Start Log Event class
****************************************************************************/
class Start_log_event: public Log_event
{
public:
@ -477,6 +523,13 @@ public:
};
/*****************************************************************************
Intvar Log Event class
Logs special variables such as auto_increment values
****************************************************************************/
class Intvar_log_event: public Log_event
{
public:
@ -503,9 +556,11 @@ public:
};
/*****************************************************************************
*
* Rand log event class
*
Rand Log Event class
Logs random seed used by the next RAND()
****************************************************************************/
class Rand_log_event: public Log_event
{
@ -531,6 +586,12 @@ class Rand_log_event: public Log_event
bool is_valid() { return 1; }
};
/*****************************************************************************
Stop Log Event class
****************************************************************************/
class Stop_log_event: public Log_event
{
public:
@ -551,6 +612,13 @@ public:
};
/*****************************************************************************
Rotate Log Event class
This will be depricated when we move to using sequence ids.
****************************************************************************/
class Rotate_log_event: public Log_event
{
public:
@ -585,6 +653,11 @@ public:
/* the classes below are for the new LOAD DATA INFILE logging */
/*****************************************************************************
Create File Log Event class
****************************************************************************/
class Create_file_log_event: public Load_log_event
{
protected:
@ -641,6 +714,11 @@ public:
};
/*****************************************************************************
Append Block Log Event class
****************************************************************************/
class Append_block_log_event: public Log_event
{
public:
@ -665,7 +743,11 @@ public:
int write_data(IO_CACHE* file);
};
/*****************************************************************************
Delete File Log Event class
****************************************************************************/
class Delete_file_log_event: public Log_event
{
public:
@ -687,6 +769,11 @@ public:
int write_data(IO_CACHE* file);
};
/*****************************************************************************
Execute Load Log Event class
****************************************************************************/
class Execute_load_log_event: public Log_event
{
public:

3
sql/sql_derived.cc
View File

@ -70,7 +70,7 @@ int mysql_derived(THD *thd, LEX *lex, SELECT_LEX_UNIT *unit, TABLE_LIST *t,
if (tables_is_opened || !(res=open_and_lock_tables(thd,tables)))
{
if (tables && setup_fields(thd,tables,item_list,0,0,1))
if (setup_fields(thd,tables,item_list,0,0,1))
{
res=-1;
goto exit;
@ -113,6 +113,7 @@ int mysql_derived(THD *thd, LEX *lex, SELECT_LEX_UNIT *unit, TABLE_LIST *t,
t->table=table;
table->derived_select_number= sl->select_number;
sl->exclude();
t->db= (tables && tables->db && tables->db[0]) ? t->db : thd->db;
t->derived=(SELECT_LEX *)0; // just in case ...
}
}

10
sql/sql_parse.cc
View File

@ -1388,10 +1388,14 @@ mysql_execute_command(THD *thd)
for (TABLE_LIST *cursor= tables;
cursor;
cursor= cursor->next)
if (cursor->derived && mysql_derived(thd, lex,
if (cursor->derived && (res=mysql_derived(thd, lex,
(SELECT_LEX_UNIT *)cursor->derived,
cursor, 0))
cursor, 0)))
{
if (res < 0)
send_error(thd,thd->killed ? ER_SERVER_SHUTDOWN : 0);
DBUG_VOID_RETURN;
}
}
if ((lex->select_lex.next_select_in_list() &&
lex->unit.create_total_list(thd, lex, &tables)) ||
@ -2781,7 +2785,7 @@ check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
found=1;
}
}
else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
else if (tables->db && check_access(thd,want_access,tables->db,&tables->grant.privilege,
0, no_errors))
return TRUE;
}

129
sql/sql_test.cc
View File

@ -26,6 +26,23 @@
/* Intern key cache variables */
extern "C" pthread_mutex_t THR_LOCK_keycache;
static const char *lock_descriptions[] =
{
"No lock",
"Low priority read lock",
"Shared Read lock",
"High priority read lock",
"Read lock without concurrent inserts",
"Write lock that allows other writers",
"Write lock, but allow reading",
"Concurrent insert lock",
"Lock Used by delayed insert",
"Low priority write lock",
"High priority write lock",
"Highest priority write lock"
};
#ifndef DBUG_OFF
void
@ -45,29 +62,11 @@ print_where(COND *cond,const char *info)
DBUG_UNLOCK_FILE;
}
}
/* This is for debugging purposes */
extern HASH open_cache;
extern TABLE *unused_tables;
static const char *lock_descriptions[] =
{
"No lock",
"Low priority read lock",
"Shared Read lock",
"High priority read lock",
"Read lock without concurrent inserts",
"Write lock that allows other writers",
"Write lock, but allow reading",
"Concurrent insert lock",
"Lock Used by delayed insert",
"Low priority write lock",
"High priority write lock",
"Highest priority write lock"
};
void print_cached_tables(void)
{
uint idx,count,unused;
@ -203,6 +202,99 @@ TEST_join(JOIN *join)
#endif
typedef struct st_debug_lock
{
ulong thread_id;
char table_name[FN_REFLEN];
bool waiting;
const char *lock_text;
enum thr_lock_type type;
} TABLE_LOCK_INFO;
static int dl_compare(TABLE_LOCK_INFO *a,TABLE_LOCK_INFO *b)
{
if (a->thread_id > b->thread_id)
return 1;
if (a->thread_id < b->thread_id)
return -1;
if (a->waiting == b->waiting)
return 0;
else if (a->waiting)
return -1;
return 1;
}
static void push_locks_into_array(DYNAMIC_ARRAY *ar, THR_LOCK_DATA *data, bool wait, const char *text)
{
if (data)
{
TABLE *table=(TABLE *)data->debug_print_param;
if (table && table->tmp_table == NO_TMP_TABLE)
{
TABLE_LOCK_INFO table_lock_info;
table_lock_info.thread_id=table->in_use->thread_id;
memcpy(table_lock_info.table_name, table->table_cache_key, table->key_length);
table_lock_info.table_name[strlen(table_lock_info.table_name)]='.';
table_lock_info.waiting=wait;
table_lock_info.lock_text=text;
table_lock_info.type=table->reginfo.lock_type; // obtainable also from THR_LOCK_DATA
VOID(push_dynamic(ar,(gptr) &table_lock_info));
}
}
}
/*
Regarding MERGE tables:
For now, the best option is to use the common TABLE *pointer for all
cases; The drawback is that for MERGE tables we will see many locks
for the merge tables even if some of them are for individual tables.
The way to solve this is to add to 'THR_LOCK' structure a pointer to
the filename and use this when printing the data.
(We can for now ignore this and just print the same name for all merge
table parts; Please add the above as a comment to the display_lock
function so that we can easily add this if we ever need this.
*/
static void display_table_locks (void)
{
LIST *list;
DYNAMIC_ARRAY saved_table_locks;
VOID(my_init_dynamic_array(&saved_table_locks,sizeof(TABLE_LOCK_INFO),open_cache.records + 20,50));
VOID(pthread_mutex_lock(&THR_LOCK_lock));
for (list=thr_lock_thread_list ; list ; list=rest(list))
{
THR_LOCK *lock=(THR_LOCK*) list->data;
VOID(pthread_mutex_lock(&lock->mutex));
push_locks_into_array(&saved_table_locks, lock->write.data, false, "Locked - write");
push_locks_into_array(&saved_table_locks, lock->write_wait.data, true, "Waiting - write");
push_locks_into_array(&saved_table_locks, lock->read.data, false, "Locked - read");
push_locks_into_array(&saved_table_locks, lock->read_wait.data, true, "Waiting - read");
VOID(pthread_mutex_unlock(&lock->mutex));
}
VOID(pthread_mutex_unlock(&THR_LOCK_lock));
if (!saved_table_locks.elements) goto end;
qsort((gptr) dynamic_element(&saved_table_locks,0,TABLE_LOCK_INFO *),saved_table_locks.elements,sizeof(TABLE_LOCK_INFO),(qsort_cmp) dl_compare);
freeze_size(&saved_table_locks);
puts("\nThread database.table_name Locked/Waiting Lock_type\n");
for (uint i=0 ; i < saved_table_locks.elements ; i++)
{
TABLE_LOCK_INFO *dl_ptr=dynamic_element(&saved_table_locks,i,TABLE_LOCK_INFO*);
printf("%-8ld%-28.28s%-22s%s\n",
dl_ptr->thread_id,dl_ptr->table_name,dl_ptr->lock_text,lock_descriptions[(int)dl_ptr->type]);
}
puts("\n\n");
end:
delete_dynamic(&saved_table_locks);
}
void mysql_print_status(THD *thd)
{
char current_dir[FN_REFLEN];
@ -268,6 +360,7 @@ Next alarm time: %lu\n",
alarm_info.max_used_alarms,
alarm_info.next_alarm_time);
#endif
display_table_locks();
fflush(stdout);
if (thd)
thd->proc_info="malloc";

14
sql/sql_yacc.yy
View File

@ -1449,20 +1449,6 @@ slave:
lex->sql_command = SQLCOM_SLAVE_STOP;
lex->type = 0;
};
|
SLAVE START_SYM slave_thread_opts
{
LEX *lex=Lex;
lex->sql_command = SQLCOM_SLAVE_START;
lex->type = 0;
}
|
SLAVE STOP_SYM slave_thread_opts
{
LEX *lex=Lex;
lex->sql_command = SQLCOM_SLAVE_STOP;
lex->type = 0;
};
slave_thread_opts:
slave_thread_opt

95
strings/longlong2str-x86.s
View File

@ -64,7 +64,7 @@ longlong2str:
jne .L150
movb $48,(%edi)
incl %edi
jmp .L164
jmp .L10_end
.align 4
.L150:
@ -81,9 +81,9 @@ longlong2str:
movl %eax,%ebp
movl %esi,%eax
divl %ebx
decl %ecx
movl %eax,%esi # quotent in ebp:esi
movb _dig_vec(%edx),%al # al is faster than dl
decl %ecx
movb %al,(%ecx) # store value in buff
.align 4
.L155:
@ -91,7 +91,7 @@ longlong2str:
ja .L153
testl %esi,%esi # rest value
jl .L153
je .L160 # Ready
je .L10_mov # Ready
movl %esi,%eax
movl $_dig_vec,%ebp
.align 4
@ -105,14 +105,14 @@ longlong2str:
movb %dl,(%ecx)
jne .L154
.L160:
.L10_mov:
movl %ecx,%esi
leal 92(%esp),%ecx # End of buffer
subl %esi,%ecx
rep
movsb
.L164:
.L10_end:
movl %edi,%eax # Pointer to end null
movb $0,(%edi) # Store the end null
@ -131,10 +131,93 @@ longlong2str:
.Lfe3:
.size longlong2str,.Lfe3-longlong2str
#
# This is almost equal to the above, except that we can do the final
# loop much more efficient
#
.align 4
.Ltmp:
.long 0xcccccccd
.align 4
.globl longlong10_to_str
.type longlong10_str,@function
longlong10_to_str:
jmp longlong2str
subl $80,%esp
pushl %ebp
pushl %esi
pushl %edi
pushl %ebx
movl 100(%esp),%esi # Lower part of val
movl 104(%esp),%ebp # Higher part of val
movl 108(%esp),%edi # get dst
movl 112(%esp),%ebx # Radix (10 or -10)
testl %ebx,%ebx
jge .L10_10 # Positive radix
negl %ebx # Change radix to positive (= 10)
testl %ebp,%ebp # Test if negative value
jge .L10_10
movb $45,(%edi) # Add sign
incl %edi
negl %esi # Change sign of val (ebp:esi)
adcl $0,%ebp
negl %ebp
.align 4
.L10_10:
leal 92(%esp),%ecx # End of buffer
movl %esi,%eax # Test if zero (for easy loop)
orl %ebp,%eax
jne .L10_30 # Not zero
# Here when value is zero
movb $48,(%edi)
incl %edi
jmp .L10_end
.align 4
.L10_20:
# val is stored in in ebp:esi
movl %ebp,%eax # High part of value
xorl %edx,%edx
divl %ebx # Divide by 10
movl %eax,%ebp
movl %esi,%eax
divl %ebx # Divide by 10
decl %ecx
movl %eax,%esi # quotent in ebp:esi
addl $48,%edx # Convert to ascii
movb %dl,(%ecx) # store value in buff
.L10_30:
testl %ebp,%ebp
ja .L10_20
testl %esi,%esi # rest value
jl .L10_20 # Unsigned, do ulonglong div once more
je .L10_mov # Ready
movl %esi,%ebx # Move val to %ebx
# The following code uses some tricks to change division by 10 to
# multiplication and shifts
movl .Ltmp,%esi # set %esi to 0xcccccccd
.L10_40:
movl %ebx,%eax
mull %esi
decl %ecx
shrl $3,%edx
leal (%edx,%edx,4),%eax
addl %eax,%eax
subb %al,%bl # %bl now contains val % 10
addb $48,%bl
movb %bl,(%ecx)
movl %edx,%ebx
testl %ebx,%ebx
jne .L10_40
jmp .L10_mov # Shared end with longlong10_to_str
.L10end:
.size longlong10_to_str,.L10end-longlong10_to_str