bug (19/26)
Brian Grossman
briang@gomer.fc.hp.com
Tue Sep 8 21:44:00 GMT 1998
public:
Item *item;
Item_copy_string(Item *i) :item(i)
{
null_value=maybe_null=item->maybe_null;
decimals=item->decimals;
max_length=item->max_length;
name=item->name;
}
~Item_copy_string() { delete item; }
enum Type type() const { return COPY_STR_ITEM; }
enum Item_result result_type () const { return STRING_RESULT; }
double val() { return 0.0; }
longlong val_int() { return 0; }
String *str(String*);
void make_field(Send_field *field) { item->make_field(field); }
void copy();
table_map used_tables() const { return (table_map) 1L; }
};
class Item_buff :public Sql_alloc {
public:
my_bool null_value;
Item_buff() :null_value(0) {}
virtual bool cmp(void)=0;
virtual ~Item_buff();
};
class Item_str_buff :public Item_buff
{
Item *item;
String value,tmp_value;
public:
Item_str_buff(Item *arg) :item(arg),value(arg->max_length) {}
bool cmp(void);
~Item_str_buff();
};
class Item_real_buff :public Item_buff
{
Item *item;
double value;
public:
Item_real_buff(Item *item_par) :item(item_par),value(0.0) {}
bool cmp(void);
};
class Item_int_buff :public Item_buff
{
Item *item;
longlong value;
public:
Item_int_buff(Item *item_par) :item(item_par),value(0) {}
bool cmp(void);
};
class Item_field_buff :public Item_buff
{
char *buff;
Field *field;
uint length;
public:
Item_field_buff(Item_field *item)
{
field=item->field;
buff= (char*) sql_calloc(length=field->pack_length());
}
bool cmp(void);
};
extern Item_buff *new_Item_buff(Item *item);
extern Item_result item_cmp_type(Item_result a,Item_result b);
extern Item *resolve_const_item(Item *item,Item *cmp_item);
# 132 "mysql_priv.h" 2
# 1 "sql_class.h" 1
#pragma interface
enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_IGNORE };
enum timestamp_type { TIMESTAMP_NONE, TIMESTAMP_DATE, TIMESTAMP_FULL };
class MYSQL_LOG {
public:
enum type { CLOSED, NORMAL, NEW };
FILE *file;
time_t last_time,query_start;
ulonglong last_insert_id;
type log_type;
char *name;
char time_buff[20],db[64 +1];
public:
MYSQL_LOG() :file(0),last_time(0),query_start(0),last_insert_id(0),name(0),
log_type(CLOSED) {}
void open(const my_string log_name,type log_type);
void new_file();
void write(enum enum_server_command command,const my_string format,...);
void write(const char *query);
void flush();
void close();
};
class CONVERT
{
const uchar *from_map,*to_map;
void convert_array(const uchar *mapping,uchar *buff,uint length);
public:
const my_string name;
CONVERT(my_string name_par,uchar *from_par,uchar *to_par)
:name(name_par),from_map(from_par),to_map(to_par) {}
friend CONVERT *get_convert_set(const char *name_ptr);
inline void convert(char *a,uint length)
{
convert_array(from_map, (uchar*) a,length);
}
bool store(String *, const char *,uint);
};
typedef struct st_copy_info {
ulong records;
ulong deleted;
ulong copied;
enum enum_duplicates handle_duplicates;
int escape_char;
} COPY_INFO;
class key_part_spec :public Sql_alloc {
public:
char *field_name;
uint length;
key_part_spec(char *name,uint len=0) :field_name(name), length(len) {}
};
class Alter_drop :public Sql_alloc {
public:
enum drop_type {KEY, COLUMN };
char *name;
enum drop_type type;
Alter_drop(enum drop_type par_type,char *par_name)
:name(par_name), type(par_type) {}
};
class Alter_column :public Sql_alloc {
public:
char *name;
Item *def;
Alter_column(char *par_name,Item *literal)
:name(par_name), def(literal) {}
};
class Key :public Sql_alloc {
public:
enum Keytype { PRIMARY, UNIQUE, MULTIPLE };
enum Keytype type;
List<key_part_spec> columns;
char *Name;
Key(enum Keytype type_par,char *name,List<key_part_spec> &cols)
:type(type_par), columns(cols),Name(name) {}
~Key() {}
char *name() { return Name; }
};
typedef struct st_mysql_lock
{
TABLE **table;
uint table_count,lock_count;
THR_LOCK_DATA **locks;
} MYSQL_LOCK;
extern uint thd_startup_options;
class THD :public ilink {
time_t start_time;
ulonglong last_insert_id;
public:
NET net;
char *host,*user,*priv_user,*db,*ip,*proc_info;
struct sockaddr_in local,remote;
uint client_capabilities,max_packet_length;
uint master_access,db_access;
TABLE *open_tables;
MYSQL_LOCK *lock,*locked_tables;
MEM_ROOT alloc;
ULL *ull;
pthread_cond_t *cond;
enum enum_server_command command;
char *query,*where,*thread_stack;
uint current_tablenr,select_distinct,tmp_table,cond_count,options;
ulong thread_id,query_id,version,select_limit,default_select_limit,
offset_limit, cuted_fields;
List<Item> item_list,field_list,value_list;
List<Key> key_list;
List<create_field> create_list;
Item *free_list;
SQL_LIST order_list,table_list,group_list,proc_list;
CONVERT *convert_set;
Field *dupp_field;
String packet;
bool set_query_id,locked,count_cuted_fields,some_tables_deleted;
bool no_errors, allow_sum_func, password, fatal_error;
bool query_start_used,last_insert_id_used,insert_id_used,user_time;
bool volatile killed;
int* mysys_abort_flag;
struct rand_struct rand;
pthread_t real_id;
sigset_t signals,block_signals;
THD()
{
host=user=db=query=ip=proc_info=0;
locked=killed=count_cuted_fields=some_tables_deleted=no_errors=password=
fatal_error=query_start_used=last_insert_id_used=insert_id_used=
user_time=0;
last_insert_id=0;
open_tables=0;
lock=locked_tables=0;
cuted_fields=0L;
options=thd_startup_options;
start_time=(time_t) 0;
cond_count=0;
command=COM_SLEEP;
set_query_id=1;
default_select_limit= (ulong) ~0L;
convert_set=0;
mysys_abort_flag=0;
db_access= 16384 ;
ull=0;
cond=0;
}
~THD();
inline time_t query_start() { query_start_used=1; return start_time; }
inline void set_time() { if (!user_time) time(&start_time); }
inline void set_time(time_t t) { start_time=t; user_time=1; }
inline void insert_id(ulonglong id)
{ last_insert_id=id; insert_id_used=1; }
inline ulonglong insert_id(void)
{
last_insert_id_used=1; return last_insert_id;
}
};
class sql_exchange :public Sql_alloc
{
public:
char *file_name;
String *field_term,*enclosed,*line_term,*line_start,*escaped;
bool opt_enclosed;
uint skip_lines;
sql_exchange(char *name);
~sql_exchange() {}
};
class select_result :public Sql_alloc {
protected:
THD *thd;
public:
select_result();
virtual ~select_result() {};
virtual int prepare(List<Item> &list ) { return 0; }
virtual bool send_fields(List<Item> &list,uint flag)=0;
virtual bool send_data(List<Item> &items)=0;
virtual void send_error(uint errcode,char *err)=0;
virtual void send_eof()=0;
};
class select_send :public select_result {
public:
select_send() {}
bool send_fields(List<Item> &list,uint flag);
bool send_data(List<Item> &items);
void send_error(uint errcode,char *err);
void send_eof();
};
class select_export :public select_result {
sql_exchange *exchange;
File file;
IO_CACHE cache;
ulong row_count;
uint field_term_length;
int field_sep_char,escape_char,line_sep_char;
bool fixed_row_size;
public:
select_export(sql_exchange *ex) :exchange(ex),file(-1),row_count(0L) {}
~select_export();
int prepare(List<Item> &list);
bool send_fields(List<Item> &list ,
uint flag ) { return 0; }
bool send_data(List<Item> &items);
void send_error(uint errcode,char *err);
void send_eof();
};
class select_insert :public select_result {
TABLE *table;
List<Item> *fields;
uint save_time_stamp;
COPY_INFO info;
public:
select_insert(TABLE *table_par,List<Item> *fields_par,enum_duplicates dup)
:table(table_par),fields(fields_par),save_time_stamp(table_par->time_stamp)
{
memset(( (gptr) &info ),0,( sizeof(info) )) ; info.handle_duplicates=dup;
}
~select_insert();
int prepare(List<Item> &list);
bool send_fields(List<Item> &list,uint flag) { return 0; }
bool send_data(List<Item> &items);
void send_error(uint errcode,char *err);
void send_eof();
};
typedef struct st_sort_field {
Field *field;
Item *item;
uint length;
my_bool reverse;
Item_result result_type;
} SORT_FIELD;
typedef struct st_sort_buffer {
uint index;
uint sort_orders;
uint change_pos;
char **buff;
SORT_FIELD *sortorder;
} SORT_BUFFER;
# 133 "mysql_priv.h" 2
# 1 "handler.h" 1
extern char bas_ext[][2][20 ];
extern uint ha_maxrecordlength[], ha_max_keys[],
ha_max_key_parts[], ha_option_flag[],ha_max_key_length;
extern int ha_panic(enum ha_panic_function flag);
extern int ha_open(TABLE *form,char *name,int mode,int test_if_locked);
extern int ha_close(TABLE *form);
extern int ha_write(TABLE *form,byte *buf);
extern int ha_update(TABLE *form,byte *old,byte *new_record);
extern int ha_delete(TABLE *form,byte *buf);
extern int ha_rkey(TABLE *form,byte *buf,int inx,byte *key,
uint key_len,enum ha_rkey_function flag);
extern int ha_rnext(TABLE *form,byte *buf,int inx);
extern int ha_rprev(TABLE *form,byte *buf,int inx);
extern int ha_rfirst(TABLE *form,byte *buf,int inx);
extern int ha_rlast(TABLE *form,byte *buf,int inx);
extern int ha_rsame(TABLE *form,byte *buf,int inx);
extern int ha_rsame_with_pos(TABLE *form,byte *buf,int inx,byte *pos);
extern int ha_r_rnd(TABLE *form,byte *buf,byte *pos);
extern int ha_readfirst(TABLE *form,byte *buf);
extern void ha_info(TABLE *form,int flag);
extern int ha_extra(TABLE *form,enum ha_extra_function function);
extern void ha_reset(TABLE *form);
extern int ha_lock(TABLE *form,int lock_type);
extern void ha_key_cache(void);
extern void ha_error(TABLE *form,int error,int errflag);
extern int ha_keyerror(TABLE *form,int error);
extern enum db_type ha_checktype(enum db_type database_type);
extern int ha_frename(enum db_type base,char *from,char *to);
extern int ha_frename (enum db_type base, const char * from, const char * to);
extern int ha_fdelete(enum db_type base,char *name);
# 134 "mysql_priv.h" 2
# 1 "select.h" 1
#pragma interface
typedef struct st_key_part {
uint16 key,part,length;
Field *field;
} KEY_PART;
class QUICK_RANGE :public Sql_alloc {
public:
char *min_key,*max_key;
uint16 min_length,max_length,flag;
QUICK_RANGE(const char *min_key_arg,uint min_length_arg,
const char *max_key_arg,uint max_length_arg,
uint flag_arg)
: min_key(sql_memdup(min_key_arg,min_length_arg+1)),
max_key(sql_memdup(max_key_arg,max_length_arg+1)),
min_length(min_length_arg),
max_length(max_length_arg),
flag(flag_arg)
{}
};
class QUICK_SELECT {
public:
bool next;
uint index;
TABLE *head;
List<QUICK_RANGE> ranges;
List_iterator<QUICK_RANGE> it;
MEM_ROOT alloc;
KEY_PART *key_parts;
ulong records;
QUICK_SELECT(uint index_arg);
~QUICK_SELECT();
void reset(void) { next=0; it.rewind(); }
int get_next();
int cmp(QUICK_RANGE *range);
};
class SQL_SELECT :public Sql_alloc {
public:
QUICK_SELECT *quick;
COND *cond;
TABLE **tables,*head;
IO_CACHE file;
ulong records;
key_map quick_keys;
table_map needed_reg;
table_map const_tables,read_tables;
bool free_cond;
SQL_SELECT();
~SQL_SELECT();
bool check_quick() { return test_quick_select(~0L,0,~0L) < 0; }
bool skipp_record() { return cond ? cond->val_int() == 0 : 0; }
int test_quick_select(key_map keys,table_map prev_tables,ulong limit);
};
# 135 "mysql_priv.h" 2
typedef List<Item> List_item;
void mysql_create_db(THD *thd, char *db);
int mysql_rm_table(THD *thd, TABLE_LIST *tables);
bool mysql_change_db(THD *thd,const char *name);
void mysql_parse(THD *thd,char *inBuf,uint length);
void * handle_one_connection (void * arg ) ;
sig_handler end_thread(int sig);
void mysql_execute_command(void);
bool do_command(THD *thd);
bool check_stack_overrun(THD *thd,char *dummy);
void reload_acl_and_cache(uint options);
void mysql_rm_db(THD *thd,char *db);
void table_cache_init(void);
void table_cache_free(void);
uint cached_tables(void);
void close_connection(NET *net,uint errcode=0,bool lock=1);
void send_error(NET *net,uint sql_errno=0, char *err=0);
void net_printf(NET *net,uint sql_errno, ...);
void send_ok(NET *net,ulong affected_rows=0L,ulong id=0L,const char *info=0);
void send_eof(NET *net,bool no_flush=0);
byte *net_store_length(byte *packet,ulong length);
byte *net_store_data(byte *to,const char *from);
byte *net_store_data(byte *to,long from);
bool net_store_null(String *packet);
bool net_store_data(String *packet,ulong from);
bool net_store_data(String *packet,const char *from);
bool net_store_data(String *packet,const byte *from,uint length);
int mysql_select(THD *thd,TABLE_LIST *tables,List<Item> &list,COND *conds,
ORDER *order, ORDER *group,Item *having,ORDER *proc_param,
uint select_type,select_result *result);
int mysql_create_table(THD *thd,const char *table_name,
List<create_field> &fields, List<Key> &keys,
bool tmp_table);
int mysql_alter_table(THD *thd, char *new_name, TABLE_LIST *table_list,
List<create_field> &fields,
List<Key> &keys,List<Alter_drop> &drop_list,
List<Alter_column> &alter_list,
bool drop_primary,enum enum_duplicates handle_duplicates);
int mysql_create_index(THD *thd,const char *table_name,List<key_part_spec> &key,
bool unique);
int mysql_update(THD *thd,TABLE_LIST *tables,List<Item> &fields,
List<Item> &values,COND *conds);
int mysql_insert(THD *thd,TABLE_LIST *table,List<Item> &fields,
List<Item> &values, enum_duplicates flag);
int mysql_delete(THD *thd,TABLE_LIST *table,COND *conds);
TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, bool update);
TABLE *open_table(THD *thd,const char *db,const char *table,const char *alias);
bool reopen_table(THD *thd,TABLE *table,bool locked=0);
bool reopen_tables(THD *thd,const char *table_name);
Field *find_field_in_tables(THD *thd,Item_field *item,TABLE_LIST *tables);
int mysqld_show_dbs(THD *thd,const char *wild);
int mysqld_show_tables(THD *thd,const char *db,const char *wild);
int mysqld_show_fields(THD *thd,const char *db,const char *table,
const char *wild);
int mysqld_show_keys(THD *thd,const char *db,const char *table);
void mysqld_list_fields(THD *thd,const char *table,const char *wild);
void mysqld_list_processes(THD *thd);
int mysqld_show_status(THD *thd);
int mysqld_show_variables(THD *thd,const char *wild);
int acl_init(void);
void acl_reload(void);
void acl_free(void);
uint acl_get(const char *host, const char *ip, const char *user,
const char *db);
uint acl_getroot(const char *host, const char *ip, const char *user,
const char *password,const char *scramble,char **priv_user,
bool old_ver);
uint acl_getconnectright(const char *host, const char *ip);
void set_item_name(Item *item,char *pos,uint length);
bool add_field_to_list(char *field_name, enum enum_field_types type,
char *length, char *decimal,
uint type_modifier,int unireg_check,
int keyinfo,Item *item,char *change,
TYPELIB *interval);
bool add_to_list(SQL_LIST &list,Item *group,bool asc=0);
TABLE_LIST *add_table_to_list(char *name,uint length,char *alias,uint flags=0);
void add_left_join_on(TABLE_LIST *a,TABLE_LIST *b,Item *expr);
void add_left_join_natural(TABLE_LIST *a,TABLE_LIST *b);
bool add_proc_to_list(Item *item);
TABLE *unlink_open_table(TABLE *list,TABLE *find);
ulong get_quick_record_count(SQL_SELECT *select,uint table,uint keys);
SQL_SELECT *make_select(TABLE **table,uint table_count,uint head,
uint const_tables, COND *conds, int *error);
Item ** find_item_in_list(Item *item,List<Item> &items);
int setup_fields(THD *thd,TABLE_LIST *tables,List<Item> &item,
bool set_query_id,List<Item> *sum_func_list);
int setup_conds(THD *thd,TABLE_LIST *tables,COND *conds);
int open_tables(THD *thd,TABLE_LIST *tables);
int open_and_lock_tables(THD *thd,TABLE_LIST *tables);
int lock_tables(THD *thd,TABLE_LIST *tables);
TABLE *open_tmp_table(THD *thd,const char *db,const char *table_name);
bool send_fields(THD *thd,List<Item> &item,uint send_field_count);
void free_io_cache(TABLE *entry);
void intern_close_table(TABLE *entry);
void close_thread_tables(THD *thd);
void remove_db_from_cache(const my_string db);
bool remove_table_from_cache(const char *db,const char *table);
void close_cached_tables(bool wait_for_refresh);
void copy_field_from_tmp_record(Field *field,int offset);
int fill_record(List<Item> &fields,List<Item> &values);
int fill_record(TABLE *table,List<Item> &values);
bool eval_const_cond(COND *cond);
int mysql_load(THD *thd,sql_exchange *ex, TABLE_LIST *table_list,
List<Item> &fields, enum enum_duplicates handle_duplicates);
int write_record(THD *thd,TABLE *table,COPY_INFO *info);
int find_ref_key(TABLE *form,Field *field);
void key_copy(byte *key,TABLE *form,uint index,uint key_length);
void key_restore(TABLE *form,byte *key,uint index,uint key_length);
int key_cmp(TABLE *form,byte *key,uint index,uint key_length);
void key_unpack(String *to,TABLE *form,uint index);
void init_errmessage(void);
extern char mysql_data_home[512 ],server_version[40],max_sort_char;
extern my_string mysql_unix_port,mysql_tmpdir;
extern ulong refresh_version,query_id,opened_tables;
extern uint test_flags,thread_count,select_errors,mysql_port,
thd_startup_options;
extern time_t start_time;
extern char *command_name[];
extern I_List<THD> threads;
extern MYSQL_LOG mysql_log,mysql_update_log;
extern pthread_key_t THR_MALLOC ;
extern pthread_key_t THR_THD ;
extern pthread_key_t THR_NET ;
extern pthread_mutex_t LOCK_mysql_create_db,LOCK_Acl,LOCK_open,
LOCK_thread_count,LOCK_mapped_file,LOCK_user_locks;
extern pthread_cond_t COND_refresh;
extern bool opt_endinfo;
extern char f_fyllchar;
extern DATE_FORMAT dayord;
extern double log_10[32];
extern uint current_pid,protocol_version;
extern ulong keybuff_size,sortbuff_size,max_item_sort_length,table_cache_size,
max_join_size,join_buff_size,tmp_table_size,thread_stack;
extern ulong specialflag;
extern bool volatile abort_loop;
extern char language[512 - 256 ],reg_ext[20 ],blob_newline;
extern char **errmesg;
extern byte last_ref[4 ];
extern String empty_string;
extern struct show_var_st variables[];
extern pthread_t signal_thread;
MYSQL_LOCK *mysql_lock_tables(THD *thd,TABLE **table,uint count);
void mysql_unlock_tables(MYSQL_LOCK *sql_lock,bool no_free=0);
void mysql_unlock_some_tables(TABLE **table,uint count);
void mysql_lock_remove(MYSQL_LOCK *locked,TABLE *table);
MYSQL_LOCK *mysql_lock_merge(MYSQL_LOCK *a,MYSQL_LOCK *b);
void unireg_init(ulong options);
void unireg_end(int signal);
int rea_create_table(my_string file_name,enum db_type database_type,
uint table_options, ulong records, ulong reloc,
List<create_field> &create_field,
uint key_count,KEY *key_info);
int format_number(uint inputflag,uint max_length,my_string pos,uint length,
my_string *errpos);
int cre_database(char *name);
int openfrm(const char *name,const char *alias,uint filestat,uint prgflag,
TABLE *outparam);
int closefrm(TABLE *table);
void free_blobs(TABLE *table);
void form_error(int error,char *name,char *formname,char *form_ext,
int errortype);
int set_zone(int nr,int min_zone,int max_zone);
ulong convert_period_to_month(ulong period);
ulong convert_month_to_period(ulong month);
long calc_daynr(uint year,uint month,uint day);
uint calc_days_in_year(uint year);
void get_date_from_daynr(long daynr,uint *year, uint *month,
uint *day);
void init_time(void);
long my_gmt_sec(TIME *);
time_t str_to_timestamp(const char *str,uint length);
ulong str_to_date(const char *str,uint length);
ulong str_to_time(const char *str,uint length);
longlong str_to_datetime(const char *str,uint length);
timestamp_type str_to_TIME(const char *str, uint length, TIME *l_time);
int test_if_number(char *str,int *res,bool allow_wildcards);
void change_byte(byte *,uint,char,char);
void unireg_abort(int exit_code);
void init_read_record(READ_RECORD *info, TABLE *reg_form, SQL_SELECT *select);
void end_read_record(READ_RECORD *info);
ulong get_ref_regs(TABLE **form,ulong reg_used);
void TEST_select(SQL_SELECT* select);
ulong filesort(TABLE **form,struct st_sort_field *sortorder, uint s_length,
SQL_SELECT *select, ulong special,ulong max_records);
void change_double_for_sort(double nr,byte *to);
int get_quick_record(SQL_SELECT *select);
int calc_weekday(long daynr);
void find_date(char *pos,uint *vek,uint flag);
TYPELIB *convert_strings_to_array_type(my_string *typelibs, my_string *end);
TYPELIB *typelib(List<String> &strings);
void clean_up(void);
ulong get_form_pos(File file, uchar *head,
my_string outname, TYPELIB *save_names);
ulong make_new_entry(File file,uchar *fileinfo,TYPELIB *formnames,
char *newname);
ulong next_io_size(ulong pos);
void append_unescaped(String *res,const char *pos);
int create_frm(char *name,uint reclength,uchar *fileinfo,
enum db_type database,uint options,
ulong records,ulong reloc,uint keys);
int rename_file_ext(const char * from,const char * to,const char * ext);
int fix_frm_ref(const char * name);
char *get_field(MEM_ROOT *mem,TABLE *table,uint fieldnr);
int wild_case_compare(const char *str,const char *wildstr);
inline THD *_current_thd(void)
{
return ( THD* ) pthread_getspecific( ( THR_THD ) ) ;
}
inline bool add_item_to_list(Item *item)
{
return _current_thd() ->item_list.push_back(item);
}
inline bool add_value_to_list(Item *value)
{
return _current_thd() ->value_list.push_back(value);
}
inline bool add_order_to_list(Item *item,bool asc)
{
return add_to_list(_current_thd() ->order_list,item,asc);
}
inline bool add_group_to_list(Item *item,bool asc)
{
return add_to_list(_current_thd() ->group_list,item,asc);
}
# 22 "sql_yacc.yy" 2
# 1 "sql_lex.h" 1
enum enum_sql_command {
SQL_SELECT,SQL_CREATE_TABLE,SQL_CREATE_INDEX,SQL_ALTER_TABLE,
SQL_UPDATE,SQL_INSERT,SQL_INSERT_SELECT,SQL_DELETE,
SQL_DROP_TABLE,SQL_DROP_INDEX,SQL_SHOW_DATABASES,
SQL_SHOW_TABLES,SQL_SHOW_FIELDS,SQL_SHOW_KEYS,
SQL_LOAD,SQL_SET_OPTION,SQL_LOCK_TABLES,SQL_UNLOCK_TABLES,SQL_GRANT,
SQL_CHANGE_DB, SQL_CREATE_DB, SQL_DROP_DB, SQL_REPLACE,
SQL_REPLACE_SELECT, SQL_SHOW_VARIABLES, SQL_SHOW_STATUS, SQL_CREATE_FUNCTION,
SQL_DROP_FUNCTION};
enum lex_states { STATE_START, STATE_CHAR, STATE_IDENT,
STATE_IDENT_SEP,
STATE_IDENT_START,
STATE_FOUND_IDENT,
STATE_SIGNED_NUMBER,
STATE_REAL,
STATE_CMP_OP,
STATE_STRING,
STATE_COMMENT,
STATE_END,
STATE_OPERATOR_OR_IDENT,
STATE_NUMBER_IDENT,
STATE_INT_OR_REAL,
STATE_REAL_OR_POINT,
STATE_BOOL,
STATE_EOL,
STATE_ESCAPE,
STATE_LONG_COMMENT
};
typedef struct st_lex {
uint yylineno,yytoklen;
void * yylval;
uchar *ptr,*tok_start,*tok_end,*end_of_query;
ulong select_limit,offset_limit;
bool create_refs,drop_primary;
enum_sql_command sql_command;
enum lex_states next_state;
uint type,options;
char *length,*db,*dec,*change,*name;
String *wild;
sql_exchange *exchange;
List<List_item> expr_list;
List<key_part_spec> col_list;
List<Alter_drop> drop_list;
List<Alter_column> alter_list;
List<String> interval_list;
TYPELIB *interval;
Item *where,*having;
bool unique_flag;
enum enum_duplicates duplicates;
CONVERT *convert_set;
char *table1,*table2;
gptr yacc_yyss,yacc_yyvs;
THD *thd;
udf_func udf;
} LEX;
void lex_init(void);
void lex_free(void);
LEX *lex_start(uchar *buf,uint length);
void lex_end(LEX *lex);
extern pthread_key_t THR_LEX ;
inline LEX *_current_lex(void)
{
return ( LEX * ) pthread_getspecific( ( THR_LEX ) ) ;
}
# 23 "sql_yacc.yy" 2
extern void yyerror(char*);
int yylex(void *yylval);
# 33 "sql_yacc.yy"
typedef union {
int num;
ulong ulong_num;
ulonglong ulonglong_num;
LEX_STRING lex_str;
char *simple_string;
Item *item;
List<Item> *item_list;
Key::Keytype key_type;
String *string;
key_part_spec *key_part;
TABLE_LIST *table_list;
udf_func *udf;
} YYSTYPE;
# 48 "sql_yacc.yy"
bool my_yyoverflow(short **a, YYSTYPE **b,int *yystacksize);
static const short yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 285, 2, 2, 2, 275, 270, 2, 282,
283, 273, 272, 284, 271, 290, 274, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 286, 287, 278,
277, 279, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
280, 2, 281, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 288, 269, 289, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
More information about the Gcc-bugs
mailing list