mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-29 02:05:57 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge abotchkov@work.mysql.com:/home/bk/mysql-4.1

Browse source 
into genie.(none):/home/hf/work/mysql-4.1


BitKeeper/etc/logging_ok:
  auto-union
include/mysql.h:
  Auto merged
sql/field.cc:
  Auto merged
sql/field.h:
  Auto merged
sql/ha_myisam.cc:
  Auto merged
sql/item.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/net_pkg.cc:
  Auto merged
sql/sql_base.cc:
  Auto merged
sql/sql_class.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/sql_show.cc:
  Auto merged
sql/sql_table.cc:
  Auto merged
This commit is contained in:
unknown 2002-10-18 15:55:21 +05:00
commit a62ee2202f
24 changed files with 775 additions and 364 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
BitKeeper/etc/logging_ok
View file

@ -19,6 +19,9 @@ heikki@donna.mysql.fi
heikki@hundin.mysql.fi
heikki@rescue.
heikki@work.mysql.com
hf@bison.(none)
hf@bisonxp.(none)
hf@genie.(none)
jani@dsl-jkl1657.dial.inet.fi
jani@hynda.(none)
jani@hynda.mysql.fi

4
client/mysqltest.c
View file

@ -314,6 +314,10 @@ int mysql_rpl_parse_enabled(MYSQL* mysql __attribute__((unused))) { return 1; }
my_bool mysql_rpl_probe(MYSQL *mysql __attribute__((unused))) { return 1; }
#endif
#ifdef EMBEDDED_LIBRARY
#define mysql_send_query mysql_real_query
#endif
#define MAX_SERVER_ARGS 20
static int embedded_server_arg_count=0;

25
include/mysql.h
View file

@ -108,6 +108,9 @@ typedef struct st_mysql_data {
unsigned int fields;
MYSQL_ROWS *data;
MEM_ROOT alloc;
#ifdef EMBEDDED_LIBRARY
MYSQL_ROWS **prev_ptr;
#endif
} MYSQL_DATA;
struct st_mysql_options {
@ -137,13 +140,20 @@ struct st_mysql_options {
a read that is replication-aware
*/
my_bool no_master_reads;
#ifdef EMBEDDED_LIBRARY
my_bool separate_thread;
#endif
};
enum mysql_option { MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_COMPRESS,
MYSQL_OPT_NAMED_PIPE, MYSQL_INIT_COMMAND,
MYSQL_READ_DEFAULT_FILE, MYSQL_READ_DEFAULT_GROUP,
MYSQL_SET_CHARSET_DIR, MYSQL_SET_CHARSET_NAME,
MYSQL_OPT_LOCAL_INFILE};
MYSQL_OPT_LOCAL_INFILE,
#ifdef EMBEDDED_LIBRARY
MYSQL_OPT_USE_RESULT
#endif
};
enum mysql_status { MYSQL_STATUS_READY,MYSQL_STATUS_GET_RESULT,
MYSQL_STATUS_USE_RESULT};
@ -156,13 +166,19 @@ enum mysql_status { MYSQL_STATUS_READY,MYSQL_STATUS_GET_RESULT,
enum mysql_rpl_type { MYSQL_RPL_MASTER, MYSQL_RPL_SLAVE,
MYSQL_RPL_ADMIN };
struct st_mysql_res;
typedef struct st_mysql
{
NET net; /* Communication parameters */
gptr connector_fd; /* ConnectorFd for SSL */
char *host,*user,*passwd,*unix_socket,*server_version,*host_info,
*info,*db;
#ifndef _0EMBEDDED_LIBRARY
char *host,*user,*passwd,*unix_socket,*server_version,*host_info,*info;
#endif
#ifdef EMBEDDED_LIBRARY
struct st_mysql_res *result;
#endif
char *db;
struct charset_info_st *charset;
MYSQL_FIELD *fields;
MEM_ROOT field_alloc;
@ -201,6 +217,9 @@ typedef struct st_mysql
typedef struct st_mysql_res {
#ifdef EMBEDDED_LIBRARY
const char *query_str;
#endif
my_ulonglong row_count;
MYSQL_FIELD *fields;
MYSQL_DATA *data;

9
include/violite.h
View file

@ -31,8 +31,13 @@
extern "C" {
#endif /* __cplusplus */
enum enum_vio_type { VIO_CLOSED, VIO_TYPE_TCPIP, VIO_TYPE_SOCKET,
VIO_TYPE_NAMEDPIPE, VIO_TYPE_SSL};
enum enum_vio_type {
VIO_CLOSED, VIO_TYPE_TCPIP, VIO_TYPE_SOCKET,
VIO_TYPE_NAMEDPIPE, VIO_TYPE_SSL
#ifdef EMBEDDED_LIBRARY
,VIO_SHARED_MEMORY, VIO_BUFFER
#endif
};
#ifndef __WIN__
#define HANDLE void *

7
libmysqld/embedded_priv.h
View file

@ -26,6 +26,9 @@ C_MODE_START
extern void start_embedded_connection(NET * net);
extern void end_embedded_connection(NET * net);
extern void lib_connection_phase(NET *net, int phase);
extern bool lib_dispatch_command(enum enum_server_command command, NET *net,
const char *arg, ulong length);
extern void init_embedded_mysql(MYSQL *mysql, int client_flag, char *db);
extern void *create_embedded_thd(Vio *vio, unsigned char *buff, int client_flag, char *db);
extern NET *get_mysql_net(MYSQL *mysql);
extern my_bool simple_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
ulong length, my_bool skipp_check);
C_MODE_END

470
libmysqld/lib_sql.cc
View file

@ -32,6 +32,7 @@
#define SCRAMBLE_LENGTH 8
C_MODE_START
#include "lib_vio.c"
#include "errmsg.h"
static int check_connections1(THD * thd);
static int check_connections2(THD * thd);
@ -41,19 +42,44 @@ static bool check_user(THD *thd, enum_server_command command,
char * get_mysql_home(){ return mysql_home;};
char * get_mysql_real_data_home(){ return mysql_real_data_home;};
bool lib_dispatch_command(enum enum_server_command command, NET *net,
const char *arg, ulong length)
my_bool simple_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
ulong length, my_bool skipp_check)
{
NET *net= &mysql->net;
my_bool result= 1;
THD *thd=(THD *) net->vio->dest_thd;
thd->store_globals(); // Fix if more than one connect
thd->net.last_error[0]=0; // Clear error message
thd->net.last_errno=0;
net_new_transaction(&thd->net);
return dispatch_command(command, thd, (char *) arg, length + 1);
/* Check that we are calling the client functions in right order */
if (mysql->status != MYSQL_STATUS_READY)
{
strmov(net->last_error,ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
return 1;
}
/* Clear result variables */
mysql->net.last_error[0]=0;
mysql->net.last_errno=0;
mysql->info=0;
mysql->affected_rows= ~(my_ulonglong) 0;
/* Clear receive buffer and vio packet list */
net_clear(net);
vio_reset(net->vio);
thd->store_globals(); // Fix if more than one connect
// thd->net.last_error[0]=0; // Clear error message
// thd->net.last_errno=0;
net_new_transaction(net);
result= dispatch_command(command, thd, (char *) arg, length + 1);
if (!skipp_check)
result= net->last_errno ? -1 : 0;
return result;
}
#ifdef _DUMMY
void lib_connection_phase(NET * net, int phase)
{
THD * thd;
@ -82,7 +108,7 @@ void start_embedded_conn1(NET * net)
Vio * v = net->vio;
if (!v)
{
v = vio_new(0,VIO_CLOSED,0);
v = vio_new(0,VIO_BUFFER,0);
net->vio = v;
}
if (v)
@ -112,9 +138,6 @@ void start_embedded_conn1(NET * net)
check_connections1(thd);
}
static int
check_connections1(THD *thd)
{
@ -210,6 +233,9 @@ check_connections2(THD * thd)
thd->password=test(passwd[0]);
return 0;
}
#else
C_MODE_END
#endif /* _DUMMY */
static bool check_user(THD *thd,enum_server_command command, const char *user,
const char *passwd, const char *db, bool check_count)
@ -593,7 +619,7 @@ void STDCALL mysql_thread_end()
void start_embedded_connection(NET * net)
{
start_embedded_conn1(net);
// start_embedded_conn1(net);
}
void end_embedded_connection(NET * net)
@ -603,3 +629,421 @@ void end_embedded_connection(NET * net)
}
} /* extern "C" */
C_MODE_START
NET *get_mysql_net(MYSQL *mysql)
{
return &((THD *)mysql->net.vio->dest_thd)->net;
}
void init_embedded_mysql(MYSQL *mysql, int client_flag, char *db)
{
THD *thd = (THD *)mysql->net.vio->dest_thd;
mysql->reconnect= 1; /* Reconnect as default */
mysql->server_status= SERVER_STATUS_AUTOCOMMIT;
mysql->protocol_version= ::protocol_version;
mysql->thread_id= thd->thread_id;
strmake(mysql->scramble_buff, thd->scramble, 8);
mysql->server_capabilities= CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB |
CLIENT_TRANSACTIONS;
mysql->server_language= MY_CHARSET_CURRENT;
mysql->server_status= thd->server_status;
mysql->client_flag= client_flag | mysql->options.client_flag;
mysql->db= db;
thd->mysql= mysql;
}
C_MODE_END
static int embedded_thd_net_init(NET *net, unsigned char *buff)
{
net->buff = buff;
if (net_buffer_length > max_allowed_packet)
max_allowed_packet= net_buffer_length;
net->buff_end= net->buff+(net->max_packet=net_buffer_length);
net->vio= NULL;
net->no_send_ok= 0;
net->error=0; net->return_errno=0; net->return_status=0;
// net->timeout=(uint) net_read_timeout; /* Timeout for read */
net->pkt_nr= net->compress_pkt_nr=0;
net->write_pos= net->read_pos = net->buff;
net->last_error[0]= 0;
net->compress= 0;
net->reading_or_writing= 0;
net->where_b = net->remain_in_buf= 0;
net->last_errno= 0;
net->query_cache_query= 0;
return 0;
}
C_MODE_START
void *create_embedded_thd(Vio *vio, unsigned char *buff, int client_flag, char *db)
{
THD * thd= new THD;
embedded_thd_net_init(&thd->net, buff);
/* if (protocol_version>9) */
thd->net.return_errno=1;
thd->thread_id= thread_id++;
if (thd->store_globals())
{
fprintf(stderr,"store_globals failed.\n");
return NULL;
}
thd->mysys_var= my_thread_var;
thd->dbug_thread_id= my_thread_id();
thd->thread_stack= (char*) &thd;
// if (thd->max_join_size == HA_POS_ERROR)
// thd->options |= OPTION_BIG_SELECTS;
thd->proc_info=0; // Remove 'login'
thd->command=COM_SLEEP;
thd->version=refresh_version;
thd->set_time();
init_sql_alloc(&thd->mem_root,8192,8192);
thd->client_capabilities= client_flag;
// thd->max_packet_length= max_allowed_packet;
thd->net.vio = vio;
// if (thd->client_capabilities & CLIENT_INTERACTIVE)
// thd->inactive_timeout= net_interactive_timeout;
if (thd->client_capabilities & CLIENT_TRANSACTIONS)
thd->net.return_status= &thd->server_status;
thd->db= db;
thd->db_length= db ? strip_sp(db) : 0;
thd->db_access= DB_ACLS;
thd->master_access= ~NO_ACCESS;
return thd;
}
C_MODE_END
bool send_fields(THD *thd, List<Item> &list, uint flag)
{
List_iterator_fast<Item> it(list);
Item *item;
MEM_ROOT *alloc;
MYSQL_FIELD *field, *client_field;
unsigned int field_count= list.elements;
MYSQL *mysql= thd->mysql;
if (!(mysql->result=(MYSQL_RES*) my_malloc(sizeof(MYSQL_RES)+
sizeof(ulong) * field_count,
MYF(MY_WME | MY_ZEROFILL))))
goto err;
mysql->field_count=field_count;
alloc= &mysql->field_alloc;
field= (MYSQL_FIELD *)alloc_root(alloc, sizeof(MYSQL_FIELD)*list.elements);
if (!field)
goto err;
client_field= field;
while ((item= it++))
{
Send_field server_field;
item->make_field(&server_field);
client_field->table= strdup_root(alloc, server_field.table_name);
client_field->name= strdup_root(alloc,server_field.col_name);
client_field->length= server_field.length;
client_field->type= server_field.type;
client_field->flags= server_field.flags;
client_field->decimals= server_field.decimals;
if (INTERNAL_NUM_FIELD(client_field))
client_field->flags|= NUM_FLAG;
if (flag & 2)
{
char buff[80];
String tmp(buff, sizeof(buff), default_charset_info), *res;
if (!(res=item->val_str(&tmp)))
client_field->def= strdup_root(alloc, "");
else
client_field->def= strdup_root(alloc, tmp.ptr());
}
else
client_field->def=0;
client_field->max_length= 0;
++client_field;
}
mysql->result->fields = field;
if (!(mysql->result->data= (MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
MYF(MY_WME | MY_ZEROFILL))))
goto err;
init_alloc_root(&mysql->result->data->alloc,8192,0); /* Assume rowlength < 8192 */
mysql->result->data->alloc.min_malloc=sizeof(MYSQL_ROWS);
mysql->result->data->rows=0;
mysql->result->data->fields=field_count;
mysql->result->field_count=field_count;
mysql->result->data->prev_ptr= &mysql->result->data->data;
mysql->result->field_alloc= mysql->field_alloc;
mysql->result->current_field=0;
mysql->result->current_row=0;
return 0;
err:
send_error(thd, ER_OUT_OF_RESOURCES); /* purecov: inspected */
return 1; /* purecov: inspected */
}
/* Get the length of next field. Change parameter to point at fieldstart */
static ulong
net_field_length(uchar **packet)
{
reg1 uchar *pos= *packet;
if (*pos < 251)
{
(*packet)++;
return (ulong) *pos;
}
if (*pos == 251)
{
(*packet)++;
return NULL_LENGTH;
}
if (*pos == 252)
{
(*packet)+=3;
return (ulong) uint2korr(pos+1);
}
if (*pos == 253)
{
(*packet)+=4;
return (ulong) uint3korr(pos+1);
}
(*packet)+=9; /* Must be 254 when here */
return (ulong) uint4korr(pos+1);
}
bool select_send::send_data(List<Item> &items)
{
List_iterator_fast<Item> li(items);
Item *item;
String *packet= &thd->packet;
MYSQL *mysql= thd->mysql;
MYSQL_DATA *result= mysql->result->data;
MYSQL_ROWS **prev_ptr= &mysql->result->data->data;
MYSQL_ROWS *cur;
MEM_ROOT *alloc= &mysql->result->data->alloc;
char *to;
int n_fields= items.elements;
uchar *cp;
MYSQL_FIELD *mysql_fields= mysql->result->fields;
MYSQL_ROW cur_field, end_field;
ulong len;
DBUG_ENTER("send_data");
if (unit->offset_limit_cnt)
{ // using limit offset,count
unit->offset_limit_cnt--;
DBUG_RETURN(0);
}
thd->packet.length(0);
while ((item=li++))
{
if (item->send(thd, packet))
{
packet->free();
my_error(ER_OUT_OF_RESOURCES, MYF(0));
DBUG_RETURN(1);
}
}
result->rows++;
if (!(cur= (MYSQL_ROWS *)alloc_root(alloc, sizeof(MYSQL_ROWS))) ||
!(cur->data= (MYSQL_ROW)alloc_root(alloc,
(n_fields + 1) * sizeof(char *) + packet->length())))
{
my_error(ER_OUT_OF_RESOURCES,MYF(0));
DBUG_RETURN(1);
}
*result->prev_ptr= cur;
result->prev_ptr= &cur->next;
to= (char*) (cur->data+n_fields+1);
cp= (uchar *)packet->ptr();
end_field= cur->data + n_fields;
for (cur_field=cur->data; cur_field<end_field; ++cur_field, ++mysql_fields)
{
if ((len= (ulong) net_field_length(&cp)) == NULL_LENGTH)
{
*cur_field = 0;
}
else
{
*cur_field= to;
memcpy(to,(char*) cp,len);
to[len]=0;
to+=len+1;
cp+=len;
if (mysql_fields->max_length < len)
mysql_fields->max_length=len;
}
}
*cur_field= to;
DBUG_RETURN(0);
}
bool do_command(THD *thd)
{
MYSQL *mysql= thd->mysql;
char *packet;
uint old_timeout;
ulong packet_length;
NET *net;
enum enum_server_command command;
DBUG_ENTER("do_command");
net= &thd->net;
thd->current_tablenr=0;
packet=0;
// old_timeout=net->timeout;
// net->timeout=(uint) thd->inactive_timeout; // Wait max for 8 hours
net->last_error[0]=0; // Clear error message
net->last_errno=0;
net_new_transaction(net);
if ((packet_length=my_net_read(net)) == packet_error)
{
DBUG_PRINT("info",("Got error reading command from socket %s",
vio_description(net->vio) ));
return TRUE;
}
else
{
packet=(char*) net->read_pos;
command = (enum enum_server_command) (uchar) packet[0];
DBUG_PRINT("info",("Command on %s = %d (%s)",
vio_description(net->vio), command,
command_name[command]));
}
// net->timeout=old_timeout; // Timeout for writing
DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
}
void
send_ok(THD *thd,ha_rows affected_rows,ulonglong id,const char *message)
{
NET *net= &thd->net;
if (net->no_send_ok) // hack for re-parsing queries
return;
DBUG_ENTER("send_ok");
MYSQL *mysql= current_thd->mysql;
mysql->affected_rows= affected_rows;
mysql->insert_id= id;
if (net->return_status)
mysql->server_status= *net->return_status;
if (message)
{
strmake(net->last_error, message, sizeof(net->last_error));
mysql->info= net->last_error;
}
DBUG_VOID_RETURN;
}
void
send_eof(THD *thd, bool no_flush)
{
/* static char eof_buff[1]= { (char) 254 };
NET *net= &thd->net;
DBUG_ENTER("send_eof");
if (net->vio != 0)
{
if (!no_flush && (thd->client_capabilities & CLIENT_PROTOCOL_41))
{
char buff[5];
uint tmp= min(thd->total_warn_count, 65535);
buff[0]=254;
int2store(buff+1, tmp);
int2store(buff+3, 0); // No flags yet
VOID(my_net_write(net,buff,5));
VOID(net_flush(net));
}
else
{
VOID(my_net_write(net,eof_buff,1));
if (!no_flush)
VOID(net_flush(net));
}
}
DBUG_VOID_RETURN;
*/
}
int embedded_send_row(THD *thd, int n_fields, char *data, int data_len)
{
MYSQL *mysql= thd->mysql;
MYSQL_DATA *result= mysql->result->data;
MYSQL_ROWS **prev_ptr= &mysql->result->data->data;
MYSQL_ROWS *cur;
MEM_ROOT *alloc= &mysql->result->data->alloc;
char *to;
uchar *cp;
MYSQL_FIELD *mysql_fields= mysql->result->fields;
MYSQL_ROW cur_field, end_field;
ulong len;
DBUG_ENTER("embedded_send_row");
result->rows++;
if (!(cur= (MYSQL_ROWS *)alloc_root(alloc, sizeof(MYSQL_ROWS))) ||
!(cur->data=
(MYSQL_ROW)alloc_root(alloc,
(n_fields + 1) * sizeof(char *) + data_len)))
{
my_error(ER_OUT_OF_RESOURCES,MYF(0));
DBUG_RETURN(1);
}
*result->prev_ptr= cur;
result->prev_ptr= &cur->next;
to= (char*) (cur->data+n_fields+1);
cp= (uchar *)data;
end_field= cur->data + n_fields;
for (cur_field=cur->data; cur_field<end_field; ++cur_field, ++mysql_fields)
{
if ((len= (ulong) net_field_length(&cp)) == NULL_LENGTH)
{
*cur_field = 0;
}
else
{
*cur_field= to;
memcpy(to,(char*) cp,len);
to[len]=0;
to+=len+1;
cp+=len;
if (mysql_fields->max_length < len)
mysql_fields->max_length=len;
}
}
*cur_field= to;
DBUG_RETURN(0);
}

27
libmysqld/lib_vio.c
View file

@ -42,14 +42,7 @@
struct st_vio
{
my_socket sd; /* my_socket - real or imaginary */
HANDLE hPipe;
my_bool localhost; /* Are we from localhost? */
int fcntl_mode; /* Buffered fcntl(sd,F_GETFL) */
struct sockaddr_in local; /* Local internet address */
struct sockaddr_in remote; /* Remote internet address */
enum enum_vio_type type; /* Type of connection */
char desc[30]; /* String description */
void *dest_thd;
char *packets, **last_packet;
char *where_in_packet, *end_of_packet;
@ -57,6 +50,7 @@ struct st_vio
MEM_ROOT root;
};
/* Initialize the communication buffer */
Vio *vio_new(my_socket sd, enum enum_vio_type type, my_bool localhost)
@ -69,6 +63,7 @@ Vio *vio_new(my_socket sd, enum enum_vio_type type, my_bool localhost)
init_alloc_root(&vio->root, 8192, 8192);
vio->root.min_malloc = sizeof(char *) + 4;
vio->last_packet = &vio->packets;
vio->type = type;
}
DBUG_RETURN(vio);
}
@ -219,4 +214,22 @@ my_bool vio_poll_read(Vio *vio,uint timeout)
return 0;
}
int create_vio(NET *net, int separate_thread)
{
Vio * v = net->vio;
if (!v)
{
v = vio_new(0, separate_thread ? VIO_SHARED_MEMORY : VIO_BUFFER, 0);
net->vio = v;
}
return !v;
}
void set_thd(Vio *v, void *thd)
{
if (v)
{
v -> dest_thd = thd;
}
}
#endif /* HAVE_VIO */

434
libmysqld/libmysqld.c
View file

@ -68,7 +68,8 @@ static MYSQL_DATA *read_rows (MYSQL *mysql,MYSQL_FIELD *fields,
static int read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row,
ulong *lengths);
static void end_server(MYSQL *mysql);
static void read_user_name(char *name);
/*static void read_user_name(char *name);
*/
static void append_wild(char *to,char *end,const char *wild);
static int send_file_to_server(MYSQL *mysql,const char *filename);
static ulong mysql_sub_escape_string(CHARSET_INFO *charset_info, char *to,
@ -211,40 +212,6 @@ static void free_rows(MYSQL_DATA *cur)
}
}
my_bool
simple_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
ulong length, my_bool skipp_check)
{
NET *net= &mysql->net;
my_bool result= 1;
/* Check that we are calling the client functions in right order */
if (mysql->status != MYSQL_STATUS_READY)
{
strmov(net->last_error,ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
goto end;
}
/* Clear result variables */
mysql->net.last_error[0]=0;
mysql->net.last_errno=0;
mysql->info=0;
mysql->affected_rows= ~(my_ulonglong) 0;
/* Clear receive buffer and vio packet list */
net_clear(net);
vio_reset(net->vio);
result = lib_dispatch_command(command, net, arg,length);
if (!skipp_check)
result= ((mysql->packet_length=net_safe_read(mysql)) == packet_error ?
1 : 0);
end:
return result;
}
static void free_old_query(MYSQL *mysql)
{
DBUG_ENTER("free_old_query");
@ -261,6 +228,8 @@ struct passwd *getpwuid(uid_t);
char* getlogin(void);
#endif
#ifdef _DUMMY
#if !defined(MSDOS) && ! defined(VMS) && !defined(__WIN__)
static void read_user_name(char *name)
{
@ -307,6 +276,7 @@ static void read_user_name(char *name)
}
#endif
#endif /*_DUMMY */
#ifdef __WIN__
static my_bool is_NT(void)
@ -391,7 +361,7 @@ end_server(MYSQL *mysql)
end_embedded_connection(&mysql->net);
mysql->net.vio= 0; /* Marker */
}
net_end(&mysql->net);
mysql->net.buff = NULL;
free_old_query(mysql);
DBUG_VOID_RETURN;
}
@ -787,99 +757,15 @@ mysql_connect(MYSQL *mysql,const char *host,
}
/*
** Note that the mysql argument must be initialized with mysql_init()
** before calling mysql_real_connect !
*/
int create_vio(NET *net, int separate_thread);
void set_thd(Vio *vio, void *thd);
MYSQL * STDCALL
mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
const char *passwd, const char *db,
uint port, const char *unix_socket,uint client_flag)
/************/
static inline int mysql_init_charset(MYSQL *mysql)
{
char buff[100],charset_name_buff[16],*end,*host_info, *charset_name;
uint pkt_length;
ulong max_allowed_packet;
NET *net= &mysql->net;
DBUG_ENTER("mysql_real_connect");
DBUG_PRINT("enter",("host: %s db: %s user: %s",
host ? host : "(Null)",
db ? db : "(Null)",
user ? user : "(Null)"));
char charset_name_buff[16], *charset_name;
net->vio = 0; /* If something goes wrong */
/* use default options */
if (mysql->options.my_cnf_file || mysql->options.my_cnf_group)
{
mysql_read_default_options(&mysql->options,
(mysql->options.my_cnf_file ?
mysql->options.my_cnf_file : "my"),
mysql->options.my_cnf_group);
my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
mysql->options.my_cnf_file=mysql->options.my_cnf_group=0;
}
/* Some empty-string-tests are done because of ODBC */
if (!host || !host[0])
host=mysql->options.host;
if (!user || !user[0])
user=mysql->options.user;
if (!passwd)
{
passwd=mysql->options.password;
}
if (!db || !db[0])
db=mysql->options.db;
port=0;
unix_socket=0;
mysql->reconnect=1; /* Reconnect as default */
mysql->server_status=SERVER_STATUS_AUTOCOMMIT;
host_info=(char*) ER(CR_EMBEDDED_CONNECTION);
if (my_net_init(net, net->vio))
{
vio_delete(net->vio);
net->last_errno=CR_OUT_OF_MEMORY;
strmov(net->last_error,ER(net->last_errno));
goto error;
}
/* Get version info */
mysql->protocol_version= PROTOCOL_VERSION; /* Assume this */
start_embedded_connection(net);
if ((pkt_length=net_safe_read(mysql)) == packet_error)
goto error;
/* Check if version of protocoll matches current one */
mysql->protocol_version= net->read_pos[0];
DBUG_DUMP("packet",(char*) net->read_pos,10);
DBUG_PRINT("info",("mysql protocol version %d, server=%d",
PROTOCOL_VERSION, mysql->protocol_version));
if (mysql->protocol_version != PROTOCOL_VERSION &&
mysql->protocol_version != PROTOCOL_VERSION-1)
{
net->last_errno= CR_VERSION_ERROR;
sprintf(net->last_error, ER(CR_VERSION_ERROR), mysql->protocol_version,
PROTOCOL_VERSION);
goto error;
}
end=strend((char*) net->read_pos+1);
mysql->thread_id=uint4korr(end+1);
end+=5;
strmake(mysql->scramble_buff,end,8);
end+=9;
if (pkt_length >= (uint) (end+1 - (char*) net->read_pos))
mysql->server_capabilities=uint2korr(end);
if (pkt_length >= (uint) (end+18 - (char*) net->read_pos))
{
/* New protocol with 16 bytes to describe server characteristics */
mysql->server_language=end[2];
mysql->server_status=uint2korr(end+3);
}
/* Set character set */
if ((charset_name=mysql->options.charset_name))
{
const char *save=charsets_dir;
@ -900,89 +786,94 @@ mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
if (!mysql->charset)
{
net->last_errno=CR_CANT_READ_CHARSET;
mysql->net.last_errno=CR_CANT_READ_CHARSET;
if (mysql->options.charset_dir)
sprintf(net->last_error,ER(net->last_errno),
sprintf(mysql->net.last_error,ER(mysql->net.last_errno),
charset_name ? charset_name : "unknown",
mysql->options.charset_dir);
else
{
char cs_dir_name[FN_REFLEN];
get_charsets_dir(cs_dir_name);
sprintf(net->last_error,ER(net->last_errno),
sprintf(mysql->net.last_error,ER(mysql->net.last_errno),
charset_name ? charset_name : "unknown",
cs_dir_name);
}
return mysql->net.last_errno;
}
return 0;
}
/*
** Note that the mysql argument must be initialized with mysql_init()
** before calling mysql_real_connect !
*/
MYSQL * STDCALL
mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
const char *passwd __attribute__((unused)), const char *db,
uint port, const char *unix_socket,uint client_flag)
{
ulong max_allowed_packet;
NET *net= &mysql->net;
char *db_name;
DBUG_ENTER("mysql_real_connect");
DBUG_PRINT("enter",("host: %s db: %s user: %s",
host ? host : "(Null)",
db ? db : "(Null)",
user ? user : "(Null)"));
/* use default options */
if (mysql->options.my_cnf_file || mysql->options.my_cnf_group)
{
mysql_read_default_options(&mysql->options,
(mysql->options.my_cnf_file ?
mysql->options.my_cnf_file : "my"),
mysql->options.my_cnf_group);
my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
mysql->options.my_cnf_file=mysql->options.my_cnf_group=0;
}
if (!db || !db[0])
db=mysql->options.db;
port=0;
unix_socket=0;
db_name = db ? my_strdup(db,MYF(MY_WME)) : NULL;
create_vio(net, mysql->options.separate_thread);
if (my_net_init(net, net->vio))
{
vio_delete(net->vio);
net->last_errno=CR_OUT_OF_MEMORY;
strmov(net->last_error,ER(net->last_errno));
goto error;
}
/* Save connection information */
if (!user) user="";
if (!passwd) passwd="";
host=LOCAL_HOST;
if (!my_multi_malloc(MYF(0),
&mysql->host_info, (uint) strlen(host_info)+1,
&mysql->host, (uint) strlen(host)+1,
&mysql->unix_socket,unix_socket ?
(uint) strlen(unix_socket)+1 : (uint) 1,
&mysql->server_version,
(uint) (end - (char*) net->read_pos),
NullS) ||
!(mysql->user=my_strdup(user,MYF(0))) ||
!(mysql->passwd=my_strdup(passwd,MYF(0))))
{
strmov(net->last_error, ER(net->last_errno=CR_OUT_OF_MEMORY));
set_thd(net->vio, create_embedded_thd(net->vio, net->buff, client_flag, db_name));
init_embedded_mysql(mysql, client_flag, db_name);
if (mysql_init_charset(mysql))
goto error;
}
strmov(mysql->host_info,host_info);
strmov(mysql->host,host);
if (unix_socket)
strmov(mysql->unix_socket,unix_socket);
else
mysql->unix_socket=0;
strmov(mysql->server_version,(char*) net->read_pos+1);
mysql->port=port;
mysql->client_flag=client_flag | mysql->options.client_flag;
DBUG_PRINT("info",("Server version = '%s' capabilites: %ld status: %d",
mysql->server_version,mysql->server_capabilities,
mysql->server_status));
/* Send client information for access check */
client_flag|=CLIENT_CAPABILITIES;
client_flag&= ~CLIENT_COMPRESS;
if (db)
client_flag|=CLIENT_CONNECT_WITH_DB;
int2store(buff,client_flag);
mysql->client_flag=client_flag;
max_allowed_packet=net->max_packet_size;
int3store(buff+2,max_allowed_packet);
if (user && user[0])
strmake(buff+5,user,32);
else
read_user_name((char*) buff+5);
#ifdef _CUSTOMCONFIG_
#include "_cust_libmysql.h";
#endif
DBUG_PRINT("info",("user: %s",buff+5));
end=scramble(strend(buff+5)+1, mysql->scramble_buff, passwd,
(my_bool) (mysql->protocol_version == 9));
if (db)
{
end=strmov(end+1,db);
mysql->db=my_strdup(db,MYF(MY_WME));
db=0;
}
if (my_net_write(net,buff,(ulong) (end-buff)) || net_flush(net))
goto error;
lib_connection_phase(net,2);
if( net_safe_read(mysql) == packet_error)
goto error;
if (db && mysql_select_db(mysql,db))
goto error;
/****
net->timeout=net_read_timeout;
*/
if (mysql->options.init_command)
{
my_bool reconnect=mysql->reconnect;
@ -1122,59 +1013,22 @@ mysql_query(MYSQL *mysql, const char *query)
return mysql_real_query(mysql,query, (ulong) strlen(query));
}
int STDCALL
mysql_send_query(MYSQL* mysql, const char* query, ulong length)
{
return simple_command(mysql, COM_QUERY, query, length, 1);
}
my_bool STDCALL
mysql_read_query_result(MYSQL *mysql)
{
uchar *pos;
ulong field_count;
MYSQL_DATA *fields;
uint length;
DBUG_ENTER("mysql_read_query_result");
NET *net= get_mysql_net(mysql);
if ((length=net_safe_read(mysql)) == packet_error)
DBUG_RETURN(1);
free_old_query(mysql); /* Free old result */
get_info:
pos=(uchar*) mysql->net.read_pos;
if ((field_count= net_field_length(&pos)) == 0)
{
mysql->affected_rows= net_field_length_ll(&pos);
mysql->insert_id= net_field_length_ll(&pos);
mysql->server_status=uint2korr(pos); pos+=2;
mysql->warning_count=uint2korr(pos); pos+=2;
if (pos < mysql->net.read_pos+length && net_field_length(&pos))
mysql->info=(char*) pos;
DBUG_RETURN(0);
}
if (field_count == NULL_LENGTH) /* LOAD DATA LOCAL INFILE */
{
int error=send_file_to_server(mysql,(char*) pos);
if ((length=net_safe_read(mysql)) == packet_error || error)
DBUG_RETURN(1);
goto get_info; /* Get info packet */
}
if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT))
mysql->server_status|= SERVER_STATUS_IN_TRANS;
if (net->last_errno)
return -1;
mysql->extra_info= net_field_length_ll(&pos); /* Maybe number of rec */
if (!(fields=read_rows(mysql,(MYSQL_FIELD*) 0,5)))
DBUG_RETURN(1);
if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,
(uint) field_count,0,
(my_bool) test(mysql->server_capabilities &
CLIENT_LONG_FLAG))))
DBUG_RETURN(1);
mysql->status=MYSQL_STATUS_GET_RESULT;
mysql->field_count=field_count;
mysql->warning_count= 0;
DBUG_RETURN(0);
if (mysql->field_count)
{
mysql->status=MYSQL_STATUS_GET_RESULT;
mysql->affected_rows= mysql->result->row_count= mysql->result->data->rows;
mysql->result->data_cursor= mysql->result->data->data;
}
return 0;
}
/****************************************************************************
@ -1277,6 +1131,23 @@ my_bool my_connect(my_socket s, const struct sockaddr *name, uint namelen,
#endif
}
/*
int STDCALL
mysql_send_query(MYSQL* mysql, const char* query, ulong length)
{
if (mysql->options.separate_thread)
{
return -1;
}
mysql->result= NULL;
free_old_query(mysql);
return simple_command(mysql, COM_QUERY, query, length, 1);
}
*/
int STDCALL
mysql_real_query(MYSQL *mysql, const char *query, ulong length)
@ -1284,8 +1155,19 @@ mysql_real_query(MYSQL *mysql, const char *query, ulong length)
DBUG_ENTER("mysql_real_query");
DBUG_PRINT("enter",("handle: %lx",mysql));
DBUG_PRINT("query",("Query = \"%s\"",query));
if (mysql_send_query(mysql, query, length))
if (mysql->options.separate_thread)
{
return -1;
}
mysql->result= NULL;
free_old_query(mysql); /* Free old result */
if (simple_command(mysql, COM_QUERY, query, length, 1))
DBUG_RETURN(-1);
DBUG_RETURN(mysql_read_query_result(mysql));
}
@ -1350,48 +1232,29 @@ send_file_to_server(MYSQL *mysql, const char *filename)
** Alloc result struct for buffered results. All rows are read to buffer.
** mysql_data_seek may be used.
**************************************************************************/
MYSQL_RES * STDCALL
mysql_store_result(MYSQL *mysql)
{
MYSQL_RES *result;
DBUG_ENTER("mysql_store_result");
MYSQL_RES *result= mysql->result;
if (!result)
return 0;
if (!mysql->fields)
DBUG_RETURN(0);
if (mysql->status != MYSQL_STATUS_GET_RESULT)
{
strmov(mysql->net.last_error,
ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
DBUG_RETURN(0);
}
mysql->status=MYSQL_STATUS_READY; /* server is ready */
if (!(result=(MYSQL_RES*) my_malloc(sizeof(MYSQL_RES)+
sizeof(ulong)*mysql->field_count,
MYF(MY_WME | MY_ZEROFILL))))
{
mysql->net.last_errno=CR_OUT_OF_MEMORY;
strmov(mysql->net.last_error, ER(mysql->net.last_errno));
DBUG_RETURN(0);
}
result->eof=1; /* Marker for buffered */
result->lengths=(ulong*) (result+1);
if (!(result->data=read_rows(mysql,mysql->fields,mysql->field_count)))
{
my_free((gptr) result,MYF(0));
DBUG_RETURN(0);
}
mysql->result= NULL;
*result->data->prev_ptr= 0;
result->eof= 1;
result->lengths= (ulong*)(result + 1);
mysql->affected_rows= result->row_count= result->data->rows;
result->data_cursor= result->data->data;
result->fields= mysql->fields;
result->field_alloc= mysql->field_alloc;
result->field_count= mysql->field_count;
result->current_field=0;
result->current_row=0; /* Must do a fetch first */
mysql->fields=0; /* fields is now in result */
DBUG_RETURN(result); /* Data fetched */
result->data_cursor= result->data->data;
mysql->status=MYSQL_STATUS_READY; /* server is ready */
return result;
}
void _0dummy()
{
send_file_to_server(NULL, NULL);
net_field_length_ll(NULL);
}
/**************************************************************************
** Alloc struct for use with unbuffered reads. Data is fetched by domand
@ -1406,41 +1269,13 @@ mysql_store_result(MYSQL *mysql)
MYSQL_RES * STDCALL
mysql_use_result(MYSQL *mysql)
{
MYSQL_RES *result;
DBUG_ENTER("mysql_use_result");
if (mysql->options.separate_thread)
DBUG_RETURN(0);
if (!mysql->fields)
DBUG_RETURN(0);
if (mysql->status != MYSQL_STATUS_GET_RESULT)
{
strmov(mysql->net.last_error,
ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
DBUG_RETURN(0);
}
if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+
sizeof(ulong)*mysql->field_count,
MYF(MY_WME | MY_ZEROFILL))))
DBUG_RETURN(0);
result->lengths=(ulong*) (result+1);
if (!(result->row=(MYSQL_ROW)
my_malloc(sizeof(result->row[0])*(mysql->field_count+1), MYF(MY_WME))))
{ /* Ptrs: to one row */
my_free((gptr) result,MYF(0));
DBUG_RETURN(0);
}
result->fields= mysql->fields;
result->field_alloc= mysql->field_alloc;
result->field_count= mysql->field_count;
result->current_field=0;
result->handle= mysql;
result->current_row= 0;
mysql->fields=0; /* fields is now in result */
mysql->status=MYSQL_STATUS_USE_RESULT;
DBUG_RETURN(result); /* Data is read to be fetched */
DBUG_RETURN(mysql_store_result(mysql));
}
/**************************************************************************
** Return next field of the query results
**************************************************************************/
@ -1788,6 +1623,9 @@ mysql_options(MYSQL *mysql,enum mysql_option option, const char *arg)
case MYSQL_OPT_COMPRESS:
mysql->options.compress=1; /* Remember for connect */
break;
case MYSQL_OPT_USE_RESULT:
mysql->options.separate_thread=1; /* Use separate thread for query execution*/
break;
case MYSQL_OPT_NAMED_PIPE:
mysql->options.named_pipe=1; /* Force named pipe */
break;
@ -1877,12 +1715,12 @@ my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql)
uint STDCALL mysql_errno(MYSQL *mysql)
{
return (mysql)->net.last_errno;
return get_mysql_net(mysql)->last_errno;
}
const char * STDCALL mysql_error(MYSQL *mysql)
{
return (mysql)->net.last_error;
return get_mysql_net(mysql)->last_error;
}
uint STDCALL mysql_warning_count(MYSQL *mysql)

18
sql/field.cc
View file

@ -4489,7 +4489,7 @@ void Field_blob::set_key_image(char *buff,uint length)
void Field_geom::get_key_image(char *buff,uint length, imagetype type)
{
length-=HA_KEY_BLOB_LENGTH;
/* length-=HA_KEY_BLOB_LENGTH;
ulong blob_length=get_length(ptr);
char *blob;
get_ptr(&blob);
@ -4504,12 +4504,19 @@ void Field_geom::get_key_image(char *buff,uint length, imagetype type)
float8store(buff+16, mbr.ymin);
float8store(buff+24, mbr.ymax);
return;
*/
Field_blob::get_key_image(buff, length, type);
}
void Field_geom::set_key_image(char *buff,uint length)
{
Field_blob::set_key_image(buff, length);
}
void Field_geom::sql_type(String &res) const
{
res.set("geometry", 8U, default_charset_info);
}
int Field_blob::key_cmp(const byte *key_ptr, uint max_key_length)
{
@ -5162,6 +5169,7 @@ uint32 calc_pack_length(enum_field_types type,uint32 length)
case FIELD_TYPE_BLOB: return 2+portable_sizeof_char_ptr;
case FIELD_TYPE_MEDIUM_BLOB: return 3+portable_sizeof_char_ptr;
case FIELD_TYPE_LONG_BLOB: return 4+portable_sizeof_char_ptr;
case FIELD_TYPE_GEOMETRY: return 2+portable_sizeof_char_ptr;
case FIELD_TYPE_SET:
case FIELD_TYPE_ENUM: abort(); return 0; // This shouldn't happen
default: return 0;
@ -5209,15 +5217,15 @@ Field *make_field(char *ptr, uint32 field_length,
f_packtype(pack_flag),
field_length);
if (f_is_geom(pack_flag))
return new Field_geom(ptr,null_pos,null_bit,
unireg_check, field_name, table,
pack_length,f_is_binary(pack_flag) != 0);
if (f_is_blob(pack_flag))
return new Field_blob(ptr,null_pos,null_bit,
unireg_check, field_name, table,
pack_length,f_is_binary(pack_flag) != 0,
default_charset_info);
if (f_is_geom(pack_flag))
return new Field_geom(ptr,null_pos,null_bit,
unireg_check, field_name, table,
pack_length,f_is_binary(pack_flag) != 0);
if (interval)
{

2
sql/field.h
View file

@ -950,6 +950,8 @@ public:
:Field_blob(len_arg, maybe_null_arg, field_name_arg,
table_arg, binary_arg, default_charset_info) {}
enum ha_base_keytype key_type() const { return HA_KEYTYPE_VARBINARY; }
enum_field_types type() const { return FIELD_TYPE_GEOMETRY;}
void sql_type(String &str) const;
void get_key_image(char *buff,uint length, imagetype type);
void set_key_image(char *buff,uint length);

4
sql/ha_myisam.cc
View file

@ -79,7 +79,7 @@ static void mi_check_print_msg(MI_CHECK *param, const char* msg_type,
net_store_data(packet, msg_type);
net_store_data(packet, msgbuf);
if (my_net_write(&thd->net, (char*)thd->packet.ptr(), thd->packet.length()))
if (SEND_ROW(thd, &thd->net, 4, (char*)thd->packet.ptr(), thd->packet.length()))
sql_print_error("Failed on my_net_write, writing to stderr instead: %s\n",
msgbuf);
return;
@ -1093,7 +1093,7 @@ int ha_myisam::create(const char *name, register TABLE *table,
keydef[i].flag|=HA_AUTO_KEY;
found_auto_increment=1;
}
if (field->type() == FIELD_TYPE_BLOB)
if ((field->type() == FIELD_TYPE_BLOB) || (field->type() == FIELD_TYPE_GEOMETRY))
{
keydef[i].seg[j].flag|=HA_BLOB_PART;
/* save number of bytes used to pack length */

3
sql/item.cc
View file

@ -444,6 +444,9 @@ bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
cause error ER_NON_UNIQ_ERROR in find_field_in_tables.
*/
SELECT_LEX *last= 0;
#ifdef EMBEDDED_LIBRARY
thd->net.last_errno= 0;
#endif
for (SELECT_LEX *sl= thd->lex.select->outer_select();
sl;
sl= sl->outer_select())

5
sql/item_strfunc.cc
View file

@ -1367,10 +1367,15 @@ String *Item_func_database::val_str(String *str)
String *Item_func_user::val_str(String *str)
{
THD *thd=current_thd;
#ifdef EMBEDDED_LIBRARY
if (str->copy("localuser@localhost", (uint)strlen("localuser@localhost")))
return &empty_string;
#else
if (str->copy((const char*) thd->user,(uint) strlen(thd->user)) ||
str->append('@') ||
str->append(thd->host ? thd->host : thd->ip ? thd->ip : ""))
return &empty_string;
#endif
return str;
}

10
sql/mysql_priv.h
View file

@ -869,3 +869,13 @@ inline void mark_as_null_row(TABLE *table)
table->status|=STATUS_NULL_ROW;
bfill(table->null_flags,table->null_bytes,255);
}
#ifdef EMBEDDED_LIBRARY
int embedded_send_row(THD *thd, int n_fields, char *data, int data_len);
#define SEND_ROW(thd, net, n_fields, data, data_len)\
embedded_send_row(thd, n_fields, data, data_len)
#else
#define SEND_ROW(thd, net, n_fields, data, data_len)\
my_net_write(net, data, data_len)
#endif

14
sql/net_pkg.cc
View file

@ -47,6 +47,12 @@ void send_error(THD *thd, uint sql_errno, const char *err)
}
}
}
#ifdef EMBEDDED_LIBRARY
net->last_errno= sql_errno;
strmake(net->last_error, err, sizeof(net->last_error)-1);
#else
if (net->vio == 0)
{
if (thd->bootstrap)
@ -69,6 +75,7 @@ void send_error(THD *thd, uint sql_errno, const char *err)
set_if_smaller(length,MYSQL_ERRMSG_SIZE-1);
}
VOID(net_write_command(net,(uchar) 255, "", 0, (char*) err,length));
#endif /* EMBEDDED_LIBRARY*/
thd->fatal_error=0; // Error message is given
thd->net.report_error= 0;
DBUG_VOID_RETURN;
@ -158,6 +165,7 @@ net_printf(THD *thd, uint errcode, ...)
length=sizeof(net->last_error)-1; /* purecov: inspected */
va_end(args);
#ifndef EMBEDDED_LIBRARY
if (net->vio == 0)
{
if (thd->bootstrap)
@ -175,6 +183,10 @@ net_printf(THD *thd, uint errcode, ...)
if (offset)
int2store(text_pos-2, errcode);
VOID(net_real_write(net,(char*) net->buff,length+head_length+1+offset));
#else
net->last_errno= errcode;
strmake(net->last_error, text_pos, length);
#endif
thd->fatal_error=0; // Error message is given
DBUG_VOID_RETURN;
}
@ -205,6 +217,7 @@ net_printf(THD *thd, uint errcode, ...)
If net->no_send_ok return without sending packet
*/
#ifndef EMBEDDED_LIBRARY
void
send_ok(THD *thd, ha_rows affected_rows, ulonglong id, const char *message)
@ -290,6 +303,7 @@ send_eof(THD *thd, bool no_flush)
}
DBUG_VOID_RETURN;
}
#endif /* EMBEDDED_LIBRARY */
/****************************************************************************

4
sql/sql_acl.cc
View file

@ -2635,8 +2635,12 @@ ulong get_table_grant(THD *thd, TABLE_LIST *table)
GRANT_TABLE *grant_table;
rw_rdlock(&LOCK_grant);
#ifdef EMBEDDED_LIBRARY
grant_table= NULL;
#else
grant_table = table_hash_search(thd->host,thd->ip,db,user,
table->real_name,0);
#endif
table->grant.grant_table=grant_table; // Remember for column test
table->grant.version=grant_version;
if (grant_table)

4
sql/sql_base.cc
View file

@ -195,7 +195,6 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *wild)
DBUG_RETURN(open_list);
}
/*
Send name and type of result to client converted to a given char set
@ -216,6 +215,8 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *wild)
1 Error (Note that in this case the error is not sent to the client)
*/
#ifndef EMBEDDED_LIBRARY
bool
send_convert_fields(THD *thd,List<Item> &list,CONVERT *convert,uint flag)
{
@ -439,6 +440,7 @@ err:
DBUG_RETURN(1); /* purecov: inspected */
}
#endif /* EMBEDDED_LIBRARY */
/*****************************************************************************
* Functions to free open table cache

3
sql/sql_class.cc
View file

@ -448,6 +448,8 @@ bool select_send::send_fields(List<Item> &list,uint flag)
}
#ifndef EMBEDDED_LIBRARY
/* Send data to client. Returns 0 if ok */
bool select_send::send_data(List<Item> &items)
@ -482,6 +484,7 @@ bool select_send::send_data(List<Item> &items)
else
DBUG_RETURN(1);
}
#endif /* EMBEDDED_LIBRARY */
bool select_send::send_eof()
{

7
sql/sql_class.h
View file

@ -335,6 +335,10 @@ class select_result;
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE 0xdeadbeef
#ifdef EMBEDDED_LIBRARY
typedef struct st_mysql;
#endif
#define THD_CHECK_SENTRY(thd) DBUG_ASSERT(thd->dbug_sentry == THD_SENTRY_MAGIC)
struct system_variables
@ -393,6 +397,9 @@ public:
struct rand_struct rand; // used for authentication
struct system_variables variables; // Changeable local variables
pthread_mutex_t LOCK_delete; // Locked before thd is deleted
#ifdef EMBEDDED_LIBRARY
struct st_mysql *mysql;
#endif
char *query; // Points to the current query,
/*

2
sql/sql_handler.cc
View file

@ -233,7 +233,7 @@ int mysql_ha_read(THD *thd, TABLE_LIST *tables,
goto err;
}
}
my_net_write(&thd->net, (char*)packet->ptr(), packet->length());
SEND_ROW(thd, &thd->net, list.elements, (char*)packet->ptr(), packet->length());
}
}
num_rows++;

8
sql/sql_parse.cc
View file

@ -839,8 +839,9 @@ err:
}
/* Execute one command from socket (query or simple command) */
#ifndef EMBEDDED_LIBRARY
/* Execute one command from socket (query or simple command) */
bool do_command(THD *thd)
{
char *packet;
@ -879,6 +880,7 @@ bool do_command(THD *thd)
DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
}
#endif /* EMBEDDED_LIBRARY */
bool dispatch_command(enum enum_server_command command, THD *thd,
char* packet, uint packet_length)
@ -3157,7 +3159,6 @@ bool add_field_to_list(char *field_name, enum_field_types type,
case FIELD_TYPE_STRING:
case FIELD_TYPE_VAR_STRING:
case FIELD_TYPE_NULL:
case FIELD_TYPE_GEOMETRY:
break;
case FIELD_TYPE_DECIMAL:
if (!length)
@ -3170,6 +3171,7 @@ bool add_field_to_list(char *field_name, enum_field_types type,
case FIELD_TYPE_TINY_BLOB:
case FIELD_TYPE_LONG_BLOB:
case FIELD_TYPE_MEDIUM_BLOB:
case FIELD_TYPE_GEOMETRY:
if (default_value) // Allow empty as default value
{
String str,*res;
@ -3305,7 +3307,7 @@ bool add_field_to_list(char *field_name, enum_field_types type,
if (new_field->length >= MAX_FIELD_WIDTH ||
(!new_field->length && !(new_field->flags & BLOB_FLAG) &&
type != FIELD_TYPE_STRING && type != FIELD_TYPE_VAR_STRING))
type != FIELD_TYPE_STRING && type != FIELD_TYPE_VAR_STRING && type != FIELD_TYPE_GEOMETRY))
{
net_printf(thd,ER_TOO_BIG_FIELDLENGTH,field_name,
MAX_FIELD_WIDTH-1); /* purecov: inspected */

3
sql/sql_select.cc
View file

@ -5358,6 +5358,9 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
{
Item *item= *group->item;
item->save_org_in_field(group->field);
#ifdef EMBEDDED_LIBRARY
join->thd->net.last_errno= 0;
#endif
/* Store in the used key if the field was 0 */
if (item->maybe_null)
group->buff[-1]=item->null_value ? 1 : 0;

46
sql/sql_show.cc
View file

@ -52,8 +52,6 @@ extern struct st_VioSSLAcceptorFd * ssl_acceptor_fd;
** Send list of databases
** A database is a directory in the mysql_data_home directory
****************************************************************************/
int
mysqld_show_dbs(THD *thd,const char *wild)
{
@ -87,8 +85,8 @@ mysqld_show_dbs(THD *thd,const char *wild)
{
packet->length(0);
net_store_data(packet, thd->variables.convert_set, file_name);
if (my_net_write(&thd->net, (char*) packet->ptr(),
packet->length()))
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)packet->ptr(), packet->length()))
DBUG_RETURN(-1);
}
}
@ -127,7 +125,8 @@ int mysqld_show_open_tables(THD *thd,const char *wild)
net_store_data(packet,convert, open_list->table);
net_store_data(packet,open_list->in_use);
net_store_data(packet,open_list->locked);
if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)packet->ptr(), packet->length()))
{
DBUG_RETURN(-1);
}
@ -169,7 +168,8 @@ int mysqld_show_tables(THD *thd,const char *db,const char *wild)
{
packet->length(0);
net_store_data(packet, thd->variables.convert_set, file_name);
if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)packet->ptr(), packet->length()))
DBUG_RETURN(-1);
}
send_eof(thd);
@ -635,9 +635,9 @@ int mysqld_extend_show_tables(THD *thd,const char *db,const char *wild)
}
close_thread_tables(thd,0);
}
if (my_net_write(&thd->net,(char*) packet->ptr(),
packet->length()))
DBUG_RETURN(-1);
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)packet->ptr(), packet->length()))
DBUG_RETURN(-1);
}
send_eof(thd);
DBUG_RETURN(0);
@ -647,7 +647,6 @@ int mysqld_extend_show_tables(THD *thd,const char *db,const char *wild)
/***************************************************************************
** List all columns in a table_list->real_name
***************************************************************************/
int
mysqld_show_fields(THD *thd, TABLE_LIST *table_list,const char *wild,
bool verbose)
@ -750,8 +749,8 @@ mysqld_show_fields(THD *thd, TABLE_LIST *table_list,const char *wild,
if (verbose)
{
/* Add grant options & comments */
col_access= get_column_grant(thd,table_list,field) & COL_ACLS;
end=tmp;
col_access= get_column_grant(thd,table_list,field) & COL_ACLS;
for (uint bitnr=0; col_access ; col_access>>=1,bitnr++)
{
if (col_access & 1)
@ -763,8 +762,9 @@ mysqld_show_fields(THD *thd, TABLE_LIST *table_list,const char *wild,
net_store_data(packet,convert, tmp+1,end == tmp ? 0 : (uint) (end-tmp-1));
net_store_data(packet, field->comment.str,field->comment.length);
}
if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
DBUG_RETURN(1);
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)packet->ptr(), packet->length()))
DBUG_RETURN(-1);
}
}
}
@ -833,8 +833,9 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list)
int3store(p, create_len);
// now we are in business :-)
if (my_net_write(&thd->net, (char*)packet->ptr(), packet->length()))
DBUG_RETURN(1);
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)packet->ptr(), packet->length()))
DBUG_RETURN(-1);
}
send_eof(thd);
DBUG_RETURN(0);
@ -956,8 +957,9 @@ mysqld_show_keys(THD *thd, TABLE_LIST *table_list)
net_store_data(packet,convert,table->file->index_type(i));
/* Comment */
net_store_data(packet,convert,"");
if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
DBUG_RETURN(1); /* purecov: inspected */
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)packet->ptr(), packet->length()))
DBUG_RETURN(-1);
}
}
send_eof(thd);
@ -1384,8 +1386,9 @@ void mysqld_list_processes(THD *thd,const char *user, bool verbose)
net_store_data(packet,convert,thd_info->query);
else
net_store_null(packet);
if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
break; /* purecov: inspected */
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)packet->ptr(), packet->length()))
break;
}
send_eof(thd);
DBUG_VOID_RETURN;
@ -1684,8 +1687,9 @@ int mysqld_show(THD *thd, const char *wild, show_var_st *variables,
net_store_data(&packet2, ""); // Safety
break;
}
if (my_net_write(&thd->net, (char*) packet2.ptr(),packet2.length()))
goto err; /* purecov: inspected */
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)packet2.ptr(), packet2.length()))
goto err;
}
}
pthread_mutex_unlock(&LOCK_status);

27
sql/sql_table.cc
View file

@ -397,6 +397,16 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
sql_field->unireg_check=Field::BLOB_FIELD;
blob_columns++;
break;
case FIELD_TYPE_GEOMETRY:
sql_field->pack_flag=FIELDFLAG_GEOM |
pack_length_to_packflag(sql_field->pack_length -
portable_sizeof_char_ptr);
if (sql_field->flags & BINARY_FLAG)
sql_field->pack_flag|=FIELDFLAG_BINARY;
sql_field->length=8; // Unireg field length
sql_field->unireg_check=Field::BLOB_FIELD;
blob_columns++;
break;
case FIELD_TYPE_VAR_STRING:
case FIELD_TYPE_STRING:
sql_field->pack_flag=0;
@ -1007,8 +1017,7 @@ static int send_check_errmsg(THD* thd, TABLE_LIST* table,
net_store_data(packet, "error");
net_store_data(packet, errmsg);
thd->net.last_error[0]=0;
if (my_net_write(&thd->net, (char*) thd->packet.ptr(),
packet->length()))
if (SEND_ROW(thd, &thd->net, 4, (char*) thd->packet.ptr(), packet->length()))
return -1;
return 1;
}
@ -1178,6 +1187,9 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
thd->open_options|= extra_open_options;
table->table = open_ltable(thd, table, lock_type);
#ifdef EMBEDDED_LIBRARY
thd->net.last_errno= 0; // these errors shouldn't get client
#endif
thd->open_options&= ~extra_open_options;
packet->length(0);
if (prepare_func)
@ -1199,7 +1211,7 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
err_msg=ER(ER_CHECK_NO_SUCH_TABLE);
net_store_data(packet, err_msg);
thd->net.last_error[0]=0;
if (my_net_write(&thd->net, (char*) thd->packet.ptr(),
if (SEND_ROW(thd, &thd->net, field_list.elements, (char*) thd->packet.ptr(),
packet->length()))
goto err;
continue;
@ -1214,7 +1226,7 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
net_store_data(packet, buff);
close_thread_tables(thd);
table->table=0; // For query cache
if (my_net_write(&thd->net, (char*) thd->packet.ptr(),
if (SEND_ROW(thd, &thd->net, field_list.elements, (char*) thd->packet.ptr(),
packet->length()))
goto err;
continue;
@ -1243,6 +1255,9 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
}
int result_code = (table->table->file->*operator_func)(thd, check_opt);
#ifdef EMBEDDED_LIBRARY
thd->net.last_errno= 0; // these errors shouldn't get client
#endif
packet->length(0);
net_store_data(packet, table_name);
net_store_data(packet, operator_name);
@ -1298,8 +1313,8 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
}
close_thread_tables(thd);
table->table=0; // For query cache
if (my_net_write(&thd->net, (char*) packet->ptr(),
packet->length()))
if (SEND_ROW(thd, &thd->net, field_list.elements,
(char *)thd->packet.ptr(), thd->packet.length()))
goto err;
}