sql_class.cc 20.3 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/*****************************************************************************
**
** This file implements classes defined in sql_class.h
** Especially the classes to handle a result from a select
**
*****************************************************************************/

#ifdef __GNUC__
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include "sql_acl.h"
#include <m_ctype.h>
#include <sys/stat.h>
33
#include <thr_alarm.h>
unknown's avatar
unknown committed
34 35 36
#ifdef	__WIN__
#include <io.h>
#endif
37 38
#include <mysys_err.h>
#include <assert.h>
unknown's avatar
unknown committed
39

40 41
extern struct rand_struct sql_rand;

unknown's avatar
unknown committed
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
/*****************************************************************************
** Instansiate templates
*****************************************************************************/

#ifdef __GNUC__
/* Used templates */
template class List<Key>;
template class List_iterator<Key>;
template class List<key_part_spec>;
template class List_iterator<key_part_spec>;
template class List<Alter_drop>;
template class List_iterator<Alter_drop>;
template class List<Alter_column>;
template class List_iterator<Alter_column>;
#endif

/****************************************************************************
** User variables
****************************************************************************/

static byte* get_var_key(user_var_entry *entry, uint *length,
			 my_bool not_used __attribute__((unused)))
{
  *length=(uint) entry->name.length;
  return (byte*) entry->name.str;
}

static void free_var(user_var_entry *entry)
{
  char *pos= (char*) entry+ALIGN_SIZE(sizeof(*entry));
  if (entry->value && entry->value != pos)
    my_free(entry->value, MYF(0));
  my_free((char*) entry,MYF(0));
}


/****************************************************************************
** Thread specific functions
****************************************************************************/

unknown's avatar
unknown committed
82
THD::THD():user_time(0),fatal_error(0),last_insert_id_used(0),
unknown's avatar
unknown committed
83 84
	   insert_id_used(0),in_lock_tables(0),
	   global_read_lock(0),bootstrap(0)
unknown's avatar
unknown committed
85
{
86
  host=user=priv_user=db=query=ip=0;
87
  host_or_ip="unknown ip";
unknown's avatar
unknown committed
88
  locked=killed=count_cuted_fields=some_tables_deleted=no_errors=password=
unknown's avatar
unknown committed
89
    query_start_used=safe_to_cache_query=0;
90 91 92
  pthread_mutex_lock(&LOCK_global_system_variables);
  variables= global_system_variables;
  pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
93
  db_length=query_length=col_access=0;
unknown's avatar
unknown committed
94 95
  query_error=0;
  next_insert_id=last_insert_id=0;
unknown's avatar
unknown committed
96
  open_tables=temporary_tables=handler_tables=0;
97
  current_tablenr=0;
unknown's avatar
unknown committed
98
  handler_items=0;
unknown's avatar
unknown committed
99 100
  tmp_table=0;
  lock=locked_tables=0;
101
  used_tables=0;
102
  cuted_fields=sent_row_count=0L;
unknown's avatar
unknown committed
103
  start_time=(time_t) 0;
unknown's avatar
unknown committed
104
  current_linfo =  0;
105
  slave_thread = 0;
106
  slave_proxy_id = 0;
107
  file_id = 0;
unknown's avatar
unknown committed
108 109
  cond_count=0;
  mysys_var=0;
110 111 112
#ifndef DBUG_OFF
  dbug_sentry=THD_SENTRY_MAGIC;
#endif  
unknown's avatar
unknown committed
113
  net.vio=0;
114
  net.last_error[0]=0;				// If error on boot
unknown's avatar
unknown committed
115
  ull=0;
unknown's avatar
unknown committed
116
  system_thread=cleanup_done=0;
117
  transaction.changed_tables = 0;
unknown's avatar
unknown committed
118 119 120 121 122 123
#ifdef	__WIN__
  real_id = 0;
#endif
#ifdef SIGNAL_WITH_VIO_CLOSE
  active_vio = 0;
#endif  
124
  pthread_mutex_init(&LOCK_delete, MY_MUTEX_INIT_FAST);
unknown's avatar
unknown committed
125 126 127 128 129

  /* Variables with default values */
  proc_info="login";
  where="field list";
  server_id = ::server_id;
130
  slave_net = 0;
131
  log_pos = 0;
unknown's avatar
unknown committed
132
  server_status= SERVER_STATUS_AUTOCOMMIT;
unknown's avatar
unknown committed
133 134 135
  update_lock_default= (variables.low_priority_updates ?
			TL_WRITE_LOW_PRIORITY :
			TL_WRITE);
unknown's avatar
unknown committed
136
  options= thd_startup_options;
137
  sql_mode=(uint) opt_sql_mode;
138
  open_options=ha_open_options;
unknown's avatar
unknown committed
139
  session_tx_isolation= (enum_tx_isolation) variables.tx_isolation;
unknown's avatar
unknown committed
140 141 142
  command=COM_CONNECT;
  set_query_id=1;
  db_access=NO_ACCESS;
143
  version=refresh_version;			// For boot
unknown's avatar
unknown committed
144 145 146

  /* Initialize sub structures */
  bzero((char*) &mem_root,sizeof(mem_root));
147
  bzero((char*) &transaction.mem_root,sizeof(transaction.mem_root));
148
  user_connect=(USER_CONN *)0;
unknown's avatar
unknown committed
149 150 151
  hash_init(&user_vars, USER_VARS_HASH_SIZE, 0, 0,
	    (hash_get_key) get_var_key,
	    (void (*)(void*)) free_var,0);
152
#ifdef USING_TRANSACTIONS
unknown's avatar
unknown committed
153
  bzero((char*) &transaction,sizeof(transaction));
154 155 156 157 158 159 160 161
  if (opt_using_transactions)
  {
    if (open_cached_file(&transaction.trans_log,
			 mysql_tmpdir, LOG_PREFIX, binlog_cache_size,
			 MYF(MY_WME)))
      killed=1;
    transaction.trans_log.end_of_file= max_binlog_cache_size;
  }
162
#endif
163 164 165 166 167 168 169 170 171 172 173 174

  /*
    We need good random number initialization for new thread
    Just coping global one will not work
  */
  {
    pthread_mutex_lock(&LOCK_thread_count);
    ulong tmp=(ulong) (rnd(&sql_rand) * 3000000);
    randominit(&rand, tmp + (ulong) start_time,
	       tmp + (ulong) thread_id);
    pthread_mutex_unlock(&LOCK_thread_count);
  }
unknown's avatar
unknown committed
175 176
}

unknown's avatar
unknown committed
177 178 179
/* Do operations that may take a long time */

void THD::cleanup(void)
unknown's avatar
unknown committed
180
{
unknown's avatar
unknown committed
181
  DBUG_ENTER("THD::cleanup");
unknown's avatar
unknown committed
182 183 184 185 186 187
  ha_rollback(this);
  if (locked_tables)
  {
    lock=locked_tables; locked_tables=0;
    close_thread_tables(this);
  }
unknown's avatar
unknown committed
188 189 190
  if (handler_tables)
  {
    open_tables=handler_tables; handler_tables=0;
unknown's avatar
unknown committed
191 192 193
    close_thread_tables(this);
  }
  close_temporary_tables(this);
194
#ifdef USING_TRANSACTIONS
195 196 197 198 199
  if (opt_using_transactions)
  {
    close_cached_file(&transaction.trans_log);
    ha_close_connection(this);
  }
200
#endif
unknown's avatar
unknown committed
201 202 203 204 205 206
  cleanup_done=1;
  DBUG_VOID_RETURN;
}

THD::~THD()
{
207
  THD_CHECK_SENTRY(this);
unknown's avatar
unknown committed
208
  DBUG_ENTER("~THD()");
209 210 211 212
  /* Ensure that no one is using THD */
  pthread_mutex_lock(&LOCK_delete);
  pthread_mutex_unlock(&LOCK_delete);

unknown's avatar
unknown committed
213 214 215 216 217 218 219 220
  /* Close connection */
  if (net.vio)
  {
    vio_delete(net.vio);
    net_end(&net); 
  }
  if (!cleanup_done)
    cleanup();
unknown's avatar
unknown committed
221
  if (global_read_lock)
222
    unlock_global_read_lock(this);
unknown's avatar
unknown committed
223 224 225 226 227 228 229 230 231
  if (ull)
  {
    pthread_mutex_lock(&LOCK_user_locks);
    item_user_lock_release(ull);
    pthread_mutex_unlock(&LOCK_user_locks);
  }
  hash_free(&user_vars);

  DBUG_PRINT("info", ("freeing host"));
232 233
  if (host != localhost)			// If not pointer to constant
    safeFree(host);
234 235
  if (user != delayed_user)
    safeFree(user);
unknown's avatar
unknown committed
236 237
  safeFree(db);
  safeFree(ip);
238
  free_root(&mem_root,MYF(0));
239
  free_root(&transaction.mem_root,MYF(0));
unknown's avatar
unknown committed
240
  mysys_var=0;					// Safety (shouldn't be needed)
241
  pthread_mutex_destroy(&LOCK_delete);
242 243
#ifndef DBUG_OFF
  dbug_sentry = THD_SENTRY_GONE;
244
#endif  
unknown's avatar
unknown committed
245 246 247
  DBUG_VOID_RETURN;
}

248

249
void THD::awake(bool prepare_to_die)
250
{
251
  THD_CHECK_SENTRY(this);
252 253
  safe_mutex_assert_owner(&LOCK_delete); 

254 255
  if (prepare_to_die)
    killed = 1;
256 257 258 259 260
  thr_alarm_kill(real_id);
#ifdef SIGNAL_WITH_VIO_CLOSE
  close_active_vio();
#endif    
  if (mysys_var)
unknown's avatar
unknown committed
261 262 263 264 265 266 267 268 269 270 271
  {
    pthread_mutex_lock(&mysys_var->mutex);
    if (!system_thread)		// Don't abort locks
      mysys_var->abort=1;
    /*
      This broadcast could be up in the air if the victim thread
      exits the cond in the time between read and broadcast, but that is
      ok since all we want to do is to make the victim thread get out
      of waiting on current_cond.
    */
    if (mysys_var->current_cond)
272
    {
unknown's avatar
unknown committed
273 274 275
      pthread_mutex_lock(mysys_var->current_mutex);
      pthread_cond_broadcast(mysys_var->current_cond);
      pthread_mutex_unlock(mysys_var->current_mutex);
276
    }
unknown's avatar
unknown committed
277 278
    pthread_mutex_unlock(&mysys_var->mutex);
  }
279 280
}

unknown's avatar
unknown committed
281 282 283 284
/*
  Remember the location of thread info, the structure needed for
  sql_alloc() and the structure for the net buffer
*/
unknown's avatar
unknown committed
285 286 287

bool THD::store_globals()
{
288 289 290 291 292 293 294
  if (my_pthread_setspecific_ptr(THR_THD,  this) ||
      my_pthread_setspecific_ptr(THR_MALLOC, &mem_root) ||
      my_pthread_setspecific_ptr(THR_NET,  &net))
    return 1;
  mysys_var=my_thread_var;
  dbug_thread_id=my_thread_id();
  return 0;
unknown's avatar
unknown committed
295 296
}

unknown's avatar
unknown committed
297

298 299 300 301 302 303 304 305 306 307 308 309 310 311
/* routings to adding tables to list of changed in transaction tables */

inline static void list_include(CHANGED_TABLE_LIST** prev,
				CHANGED_TABLE_LIST* curr,
				CHANGED_TABLE_LIST* new_table)
{
  if (new_table)
  {
    *prev = new_table;
    (*prev)->next = curr;
  }
}

/* add table to list of changed in transaction tables */
312

313 314
void THD::add_changed_table(TABLE *table)
{
315
  DBUG_ENTER("THD::add_changed_table(table)");
316

unknown's avatar
unknown committed
317
  DBUG_ASSERT((options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) &&
318
	      table->file->has_transactions());
unknown's avatar
unknown committed
319 320
  add_changed_table(table->table_cache_key, table->key_length);
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
321
}
322

unknown's avatar
unknown committed
323 324 325
void THD::add_changed_table(const char *key, long key_length)
{
  DBUG_ENTER("THD::add_changed_table(key)");
326 327 328
  CHANGED_TABLE_LIST** prev = &transaction.changed_tables;
  CHANGED_TABLE_LIST* curr = transaction.changed_tables;

329
  for (; curr; prev = &(curr->next), curr = curr->next)
330
  {
unknown's avatar
unknown committed
331
    int cmp =  (long)curr->key_length - (long)key_length;
332 333
    if (cmp < 0)
    {
unknown's avatar
unknown committed
334
      list_include(prev, curr, changed_table_dup(key, key_length));
335
      DBUG_PRINT("info", 
unknown's avatar
unknown committed
336
		 ("key_length %u %u", key_length, (*prev)->key_length));
337 338 339 340
      DBUG_VOID_RETURN;
    }
    else if (cmp == 0)
    {
unknown's avatar
unknown committed
341
      cmp = memcmp(curr->key, key, curr->key_length);
342 343
      if (cmp < 0)
      {
unknown's avatar
unknown committed
344
	list_include(prev, curr, changed_table_dup(key, key_length));
345
	DBUG_PRINT("info", 
unknown's avatar
unknown committed
346
		   ("key_length %u %u", key_length,
347
		    (*prev)->key_length));
348 349 350 351 352 353 354 355 356
	DBUG_VOID_RETURN;
      }
      else if (cmp == 0)
      {
	DBUG_PRINT("info", ("already in list"));
	DBUG_VOID_RETURN;
      }
    }
  }
unknown's avatar
unknown committed
357 358
  *prev = changed_table_dup(key, key_length);
  DBUG_PRINT("info", ("key_length %u %u", key_length,
359
		      (*prev)->key_length));
360 361 362
  DBUG_VOID_RETURN;
}

363

unknown's avatar
unknown committed
364
CHANGED_TABLE_LIST* THD::changed_table_dup(const char *key, long key_length)
365 366 367
{
  CHANGED_TABLE_LIST* new_table = 
    (CHANGED_TABLE_LIST*) trans_alloc(ALIGN_SIZE(sizeof(CHANGED_TABLE_LIST))+
unknown's avatar
unknown committed
368
				      key_length + 1);
369 370 371
  if (!new_table)
  {
    my_error(EE_OUTOFMEMORY, MYF(ME_BELL),
unknown's avatar
unknown committed
372
	     ALIGN_SIZE(sizeof(TABLE_LIST)) + key_length + 1);
373 374 375 376 377 378 379
    killed= 1;
    return 0;
  }

  new_table->key = (char *) (((byte*)new_table)+
			     ALIGN_SIZE(sizeof(CHANGED_TABLE_LIST)));
  new_table->next = 0;
unknown's avatar
unknown committed
380 381
  new_table->key_length = key_length;
  ::memcpy(new_table->key, key, key_length);
382 383 384 385
  return new_table;
}


unknown's avatar
unknown committed
386 387 388 389 390 391 392 393 394 395 396 397
#ifdef SIGNAL_WITH_VIO_CLOSE
void THD::close_active_vio()
{
  safe_mutex_assert_owner(&LOCK_delete); 
  if (active_vio)
  {
    vio_close(active_vio);
    active_vio = 0;
  }
}
#endif

unknown's avatar
unknown committed
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
/*****************************************************************************
** Functions to provide a interface to select results
*****************************************************************************/

select_result::select_result()
{
  thd=current_thd;
}

static String default_line_term("\n"),default_escaped("\\"),
	      default_field_term("\t");

sql_exchange::sql_exchange(char *name,bool flag)
  :file_name(name), opt_enclosed(0), dumpfile(flag), skip_lines(0)
{
  field_term= &default_field_term;
  enclosed=   line_start= &empty_string;
  line_term=  &default_line_term;
  escaped=    &default_escaped;
}

bool select_send::send_fields(List<Item> &list,uint flag)
{
  return ::send_fields(thd,list,flag);
}


/* Send data to client. Returns 0 if ok */

bool select_send::send_data(List<Item> &items)
{
unknown's avatar
unknown committed
429
  List_iterator_fast<Item> li(items);
unknown's avatar
unknown committed
430 431 432 433 434 435 436 437 438 439 440 441
  String *packet= &thd->packet;
  DBUG_ENTER("send_data");

  if (thd->offset_limit)
  {						// using limit offset,count
    thd->offset_limit--;
    DBUG_RETURN(0);
  }
  packet->length(0);				// Reset packet
  Item *item;
  while ((item=li++))
  {
442
    if (item->send(thd, packet))
unknown's avatar
unknown committed
443 444 445 446 447 448
    {
      packet->free();				// Free used
      my_error(ER_OUT_OF_RESOURCES,MYF(0));
      DBUG_RETURN(1);
    }
  }
449
  thd->sent_row_count++;
unknown's avatar
unknown committed
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
  bool error=my_net_write(&thd->net,(char*) packet->ptr(),packet->length());
  DBUG_RETURN(error);
}

bool select_send::send_eof()
{
  /* Unlock tables before sending packet to gain some speed */
  if (thd->lock)
  {
    mysql_unlock_tables(thd, thd->lock); thd->lock=0;
  }
  ::send_eof(&thd->net);
  return 0;
}


/***************************************************************************
** Export of select to textfile
***************************************************************************/


select_export::~select_export()
{
  if (file >= 0)
  {					// This only happens in case of error
    (void) end_io_cache(&cache);
    (void) my_close(file,MYF(0));
    file= -1;
  }
479
  thd->sent_row_count=row_count;
unknown's avatar
unknown committed
480 481 482 483 484 485 486 487 488 489 490
}

int
select_export::prepare(List<Item> &list)
{
  char path[FN_REFLEN];
  uint option=4;
  bool blob_flag=0;
#ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS
  option|=1;					// Force use of db directory
#endif
unknown's avatar
unknown committed
491
  if ((uint) strlen(exchange->file_name) + NAME_LEN >= FN_REFLEN)
unknown's avatar
unknown committed
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
    strmake(path,exchange->file_name,FN_REFLEN-1);
  (void) fn_format(path,exchange->file_name, thd->db ? thd->db : "", "",
		   option);
  if (!access(path,F_OK))
  {
    my_error(ER_FILE_EXISTS_ERROR,MYF(0),exchange->file_name);
    return 1;
  }
  /* Create the file world readable */
  if ((file=my_create(path, 0666, O_WRONLY, MYF(MY_WME))) < 0)
    return 1;
#ifdef HAVE_FCHMOD
  (void) fchmod(file,0666);			// Because of umask()
#else
  (void) chmod(path,0666);
#endif
  if (init_io_cache(&cache,file,0L,WRITE_CACHE,0L,1,MYF(MY_WME)))
  {
    my_close(file,MYF(0));
    file= -1;
    return 1;
  }
  /* Check if there is any blobs in data */
  {
unknown's avatar
unknown committed
516
    List_iterator_fast<Item> li(list);
unknown's avatar
unknown committed
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
    Item *item;
    while ((item=li++))
    {
      if (item->max_length >= MAX_BLOB_WIDTH)
      {
	blob_flag=1;
	break;
      }
    }
  }
  field_term_length=exchange->field_term->length();
  if (!exchange->line_term->length())
    exchange->line_term=exchange->field_term;	// Use this if it exists
  field_sep_char= (exchange->enclosed->length() ? (*exchange->enclosed)[0] :
		   field_term_length ? (*exchange->field_term)[0] : INT_MAX);
  escape_char=	(exchange->escaped->length() ? (*exchange->escaped)[0] : -1);
  line_sep_char= (exchange->line_term->length() ?
		  (*exchange->line_term)[0] : INT_MAX);
  if (!field_term_length)
    exchange->opt_enclosed=0;
  if (!exchange->enclosed->length())
    exchange->opt_enclosed=1;			// A little quicker loop
  fixed_row_size= (!field_term_length && !exchange->enclosed->length() &&
		   !blob_flag);
  return 0;
}


bool select_export::send_data(List<Item> &items)
{

  DBUG_ENTER("send_data");
  char buff[MAX_FIELD_WIDTH],null_buff[2],space[MAX_FIELD_WIDTH];
  bool space_inited=0;
  String tmp(buff,sizeof(buff)),*res;
  tmp.length(0);

  if (thd->offset_limit)
  {						// using limit offset,count
    thd->offset_limit--;
    DBUG_RETURN(0);
  }
  row_count++;
  Item *item;
  char *buff_ptr=buff;
  uint used_length=0,items_left=items.elements;
unknown's avatar
unknown committed
563
  List_iterator_fast<Item> li(items);
unknown's avatar
unknown committed
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650

  if (my_b_write(&cache,(byte*) exchange->line_start->ptr(),
		 exchange->line_start->length()))
    goto err;
  while ((item=li++))
  {
    Item_result result_type=item->result_type();
    res=item->str_result(&tmp);
    if (res && (!exchange->opt_enclosed || result_type == STRING_RESULT))
    {
      if (my_b_write(&cache,(byte*) exchange->enclosed->ptr(),
		     exchange->enclosed->length()))
	goto err;
    }
    if (!res)
    {						// NULL
      if (!fixed_row_size)
      {
	if (escape_char != -1)			// Use \N syntax
	{
	  null_buff[0]=escape_char;
	  null_buff[1]='N';
	  if (my_b_write(&cache,(byte*) null_buff,2))
	    goto err;
	}
	else if (my_b_write(&cache,(byte*) "NULL",4))
	  goto err;
      }
      else
      {
	used_length=0;				// Fill with space
      }
    }
    else
    {
      if (fixed_row_size)
	used_length=min(res->length(),item->max_length);
      else
	used_length=res->length();
      if (result_type == STRING_RESULT && escape_char != -1)
      {
	char *pos,*start,*end;

	for (start=pos=(char*) res->ptr(),end=pos+used_length ;
	     pos != end ;
	     pos++)
	{
#ifdef USE_MB
	  if (use_mb(default_charset_info))
	  {
	    int l;
	    if ((l=my_ismbchar(default_charset_info, pos, end)))
	    {
	      pos += l-1;
	      continue;
	    }
	  }
#endif
	  if ((int) *pos == escape_char || (int) *pos == field_sep_char ||
	      (int) *pos == line_sep_char || !*pos)
	  {
	    char tmp_buff[2];
	    tmp_buff[0]= escape_char;
	    tmp_buff[1]= *pos ? *pos : '0';
	    if (my_b_write(&cache,(byte*) start,(uint) (pos-start)) ||
		my_b_write(&cache,(byte*) tmp_buff,2))
	      goto err;
	    start=pos+1;
	  }
	}
	if (my_b_write(&cache,(byte*) start,(uint) (pos-start)))
	  goto err;
      }
      else if (my_b_write(&cache,(byte*) res->ptr(),used_length))
	goto err;
    }
    if (fixed_row_size)
    {						// Fill with space
      if (item->max_length > used_length)
      {
	/* QQ:  Fix by adding a my_b_fill() function */
	if (!space_inited)
	{
	  space_inited=1;
	  bfill(space,sizeof(space),' ');
	}
	uint length=item->max_length-used_length;
651
	for (; length > sizeof(space) ; length-=sizeof(space))
unknown's avatar
unknown committed
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
	{
	  if (my_b_write(&cache,(byte*) space,sizeof(space)))
	    goto err;
	}
	if (my_b_write(&cache,(byte*) space,length))
	  goto err;
      }
    }
    buff_ptr=buff;				// Place separators here
    if (res && (!exchange->opt_enclosed || result_type == STRING_RESULT))
    {
      memcpy(buff_ptr,exchange->enclosed->ptr(),exchange->enclosed->length());
      buff_ptr+=exchange->enclosed->length();
    }
    if (--items_left)
    {
      memcpy(buff_ptr,exchange->field_term->ptr(),field_term_length);
      buff_ptr+=field_term_length;
    }
    if (my_b_write(&cache,(byte*) buff,(uint) (buff_ptr-buff)))
      goto err;
  }
  if (my_b_write(&cache,(byte*) exchange->line_term->ptr(),
		 exchange->line_term->length()))
    goto err;
  DBUG_RETURN(0);
err:
  DBUG_RETURN(1);
}


void select_export::send_error(uint errcode,const char *err)
{
685 686 687 688
  ::send_error(&thd->net,errcode,err);
  (void) end_io_cache(&cache);
  (void) my_close(file,MYF(0));
  file= -1;
unknown's avatar
unknown committed
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
}


bool select_export::send_eof()
{
  int error=test(end_io_cache(&cache));
  if (my_close(file,MYF(MY_WME)))
    error=1;
  if (error)
    ::send_error(&thd->net);
  else
    ::send_ok(&thd->net,row_count);
  file= -1;
  return error;
}


/***************************************************************************
** Dump  of select to a binary file
***************************************************************************/


select_dump::~select_dump()
{
  if (file >= 0)
  {					// This only happens in case of error
    (void) end_io_cache(&cache);
    (void) my_close(file,MYF(0));
    file= -1;
  }
}

int
select_dump::prepare(List<Item> &list __attribute__((unused)))
{
  uint option=4;
#ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS
  option|=1;					// Force use of db directory
#endif
  (void) fn_format(path,exchange->file_name, thd->db ? thd->db : "", "",
		   option);
  if (!access(path,F_OK))
  {
    my_error(ER_FILE_EXISTS_ERROR,MYF(0),exchange->file_name);
    return 1;
  }
  /* Create the file world readable */
  if ((file=my_create(path, 0666, O_WRONLY, MYF(MY_WME))) < 0)
    return 1;
#ifdef HAVE_FCHMOD
  (void) fchmod(file,0666);			// Because of umask()
#else
  (void) chmod(path,0666);
#endif
  if (init_io_cache(&cache,file,0L,WRITE_CACHE,0L,1,MYF(MY_WME)))
  {
    my_close(file,MYF(0));
    my_delete(path,MYF(0));
    file= -1;
    return 1;
  }
  return 0;
}


bool select_dump::send_data(List<Item> &items)
{
unknown's avatar
unknown committed
756
  List_iterator_fast<Item> li(items);
unknown's avatar
unknown committed
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
  char buff[MAX_FIELD_WIDTH];
  String tmp(buff,sizeof(buff)),*res;
  tmp.length(0);
  Item *item;
  DBUG_ENTER("send_data");

  if (thd->offset_limit)
  {						// using limit offset,count
    thd->offset_limit--;
    DBUG_RETURN(0);
  }
  if (row_count++ > 1) 
  {
    my_error(ER_TOO_MANY_ROWS,MYF(0));
    goto err;
  }
  while ((item=li++))
  {
    res=item->str_result(&tmp);
776
    if (!res)					// If NULL
unknown's avatar
unknown committed
777
    {
778 779
      if (my_b_write(&cache,(byte*) "",1))
	goto err;
unknown's avatar
unknown committed
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
    }
    else if (my_b_write(&cache,(byte*) res->ptr(),res->length()))
    {
      my_error(ER_ERROR_ON_WRITE,MYF(0), path, my_errno);
      goto err;
    }
  }
  DBUG_RETURN(0);
err:
  DBUG_RETURN(1);
}


void select_dump::send_error(uint errcode,const char *err)
{
  ::send_error(&thd->net,errcode,err);
  (void) end_io_cache(&cache);
  (void) my_close(file,MYF(0));
  (void) my_delete(path,MYF(0));		// Delete file on error
  file= -1;
}


bool select_dump::send_eof()
{
  int error=test(end_io_cache(&cache));
  if (my_close(file,MYF(MY_WME)))
    error=1;
  if (error)
    ::send_error(&thd->net);
  else
    ::send_ok(&thd->net,row_count);
  file= -1;
  return error;
}