~drizzle-trunk/drizzle/development

 

#ifdef USE_PRAGMA_IMPLEMENTATION

#pragma implementation                          // gcc: Class implementation

#endif

 

#include "mysql_priv.h"

#include "slave.h"

#include <my_bitmap.h>

#include <m_ctype.h>

#include <thr_alarm.h>

#include <mysys_err.h>

extern "C" uchar *get_var_key(user_var_entry *entry, size_t *length,

                              my_bool not_used __attribute__((unused)))

  return (uchar*) entry->name.str;

    my_free(entry->value, MYF(0));

  my_free((char*) entry,MYF(0));

      swap_variables(Key*, a, b);               // Put shorter key in 'a'

    swap_variables(Key*, a, b);                 // Put generated key in 'a'

                              const char *calling_function __attribute__((__unused__)),

                              const char *calling_file __attribute__((__unused__)),

                              const unsigned int calling_line __attribute__((__unused__)))

  const char *old_info= thd->proc_info;

  thd->proc_info= info;

/*

  Dumps a text description of a thread, its security context

  (user, host) and the current query.

 

  SYNOPSIS

    thd_security_context()

    thd                 current thread context

    buffer              pointer to preferred result buffer

    length              length of buffer

    max_query_len       how many chars of query to copy (0 for all)

 

  RETURN VALUES

    pointer to string

*/

extern "C"

char *thd_security_context(THD *thd, char *buffer, unsigned int length,

                           unsigned int max_query_len)

{

  String str(buffer, length, &my_charset_latin1);

  const Security_context *sctx= &thd->main_security_ctx;

  char header[64];

  int len;

 

  len= snprintf(header, sizeof(header),

                "MySQL thread id %lu, query id %lu",

                thd->thread_id, (ulong) thd->query_id);

  str.length(0);

  str.append(header, len);

 

  if (sctx->host)

  {

    str.append(' ');

    str.append(sctx->host);

  }

 

  if (sctx->ip)

  {

    str.append(' ');

    str.append(sctx->ip);

  }

 

  if (sctx->user)

  {

    str.append(' ');

    str.append(sctx->user);

  }

 

  if (thd->proc_info)

  {

    str.append(' ');

    str.append(thd->proc_info);

  }

 

  if (thd->query)

  {

    if (max_query_len < 1)

      len= thd->query_length;

    else

      len= min(thd->query_length, max_query_len);

    str.append('\n');

    str.append(thd->query, len);

  }

  if (str.c_ptr_safe() == buffer)

    return buffer;

  return thd->strmake(str.ptr(), str.length());

}

 

Diagnostics_area::set_error_status(THD *thd __attribute__((__unused__)),

                                   uint sql_errno_arg,

   :Statement(&main_lex, &main_mem_root, CONVENTIONAL_EXECUTION,

   m_lip(NULL),

  /*

    @todo The following is a work around for online backup and the DDL blocker.

          It should be removed when the generalized solution is in place.

          This is needed to ensure the restore (which uses DDL) is not blocked

          when the DDL blocker is engaged.

  */

   DDL_exception(false)

  stmt_arena= this;

  bzero(&variables, sizeof(variables));

  bzero(ha_data, sizeof(ha_data));

  enable_slow_log= 0;

#ifdef SIGNAL_WITH_VIO_CLOSE

  active_vio = 0;

#endif

    bzero((char*) &user_var_events, sizeof(user_var_events));

  tmp= sql_rnd_with_mutex();

bool THD::handle_error(uint sql_errno, const char *message,

                       MYSQL_ERROR::enum_warning_level level)

void *thd_alloc(MYSQL_THD thd, unsigned int size)

void *thd_calloc(MYSQL_THD thd, unsigned int size)

char *thd_strdup(MYSQL_THD thd, const char *str)

char *thd_strmake(MYSQL_THD thd, const char *str, unsigned int size)

void *thd_memdup(MYSQL_THD thd, const void* str, unsigned int size)

void thd_get_xid(const MYSQL_THD thd, MYSQL_XID *xid)

  *xid = *(MYSQL_XID *) &thd->transaction.xid_state.xid;

  bzero((char*) warn_count, sizeof(warn_count));

  bzero((char *) &status_var, sizeof(status_var));

  my_free((char*) variables.time_format, MYF(MY_ALLOW_ZERO_PTR));

  my_free((char*) variables.date_format, MYF(MY_ALLOW_ZERO_PTR));

  my_free((char*) variables.datetime_format, MYF(MY_ALLOW_ZERO_PTR));

    vio_delete(net.vio);

  safeFree(db);

  ulong *end= (ulong*) ((uchar*) to_var +

  ulong *end= (ulong*) ((uchar*) to_var + offsetof(STATUS_VAR,

#ifdef SIGNAL_WITH_VIO_CLOSE

    if (this != current_thd)

    {

      /*

        In addition to a signal, let's close the socket of the thread that

        is being killed. This is to make sure it does not block if the

        signal is lost. This needs to be done only on platforms where

        signals are not a reliable interruption mechanism.

 

        If we're killing ourselves, we know that we're not blocked, so this

        hack is not used.

      */

 

      close_active_vio();

    }

#endif    

                                 const char* str, uint length,

bool THD::convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,

                         const char *from, uint from_length,

                         CHARSET_INFO *from_cs)

  uint dummy_errors;

bool THD::convert_string(String *s, CHARSET_INFO *from_cs, CHARSET_INFO *to_cs)

  uint dummy_errors;

  uint32 not_used;

inline static void list_include(CHANGED_TABLE_LIST** prev,

                                CHANGED_TABLE_LIST* curr,

                                CHANGED_TABLE_LIST* new_table)

void THD::add_changed_table(TABLE *table)

  CHANGED_TABLE_LIST **prev_changed = &transaction.changed_tables;

  CHANGED_TABLE_LIST *curr = transaction.changed_tables;

CHANGED_TABLE_LIST* THD::changed_table_dup(const char *key, long key_length)

  CHANGED_TABLE_LIST* new_table = 

    (CHANGED_TABLE_LIST*) trans_alloc(ALIGN_SIZE(sizeof(CHANGED_TABLE_LIST))+

             ALIGN_SIZE(sizeof(TABLE_LIST)) + key_length + 1);

  new_table->key= ((char*)new_table)+ ALIGN_SIZE(sizeof(CHANGED_TABLE_LIST));

  CHARSET_INFO *cs= system_charset_info;

  field_list.push_back(new Item_return_int("id",3, MYSQL_TYPE_LONGLONG));

                                                 MYSQL_TYPE_LONGLONG));

#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;

  }

  return;

}

#endif

 

  static void *operator new(size_t size __attribute__((__unused__)),

  static void operator delete(void *ptr __attribute__((__unused__)),

                              size_t size __attribute__((__unused__)))

  static void operator delete(void *ptr __attribute__((__unused__)),

                              void *mem __attribute__((__unused__)))

  thd->mem_root (due to possible set_n_backup_active_arena called for thd).

/**

  Check that the endpoint is still available.

*/

 

bool THD::vio_is_connected()

{

  uint bytes= 0;

 

  /* End of input is signaled by poll if the socket is aborted. */

  if (vio_poll_read(net.vio, 0))

    return true;

 

  /* Socket is aborted if signaled but no data is available. */

  if (vio_peek_read(net.vio, &bytes))

    return true;

 

  return bytes ? true : false;

}

 

 

void select_result::send_error(uint errcode,const char *err)

static String default_xml_row_term("<row>", default_charset_info);

  line_term=  filetype == FILETYPE_CSV ?

              &default_line_term : &default_xml_row_term;

bool select_send::send_fields(List<Item> &list, uint flags)

void select_to_file::send_error(uint errcode,const char *err)

  uint option= MY_UNPACK_FILENAME | MY_RELATIVE_PATH;

             NullS);

                   (int) (uchar) (*exchange->field_term)[0] : INT_MAX;

                  (int) (uchar) (*exchange->enclosed)[0] : field_term_char);

                (int) (uchar) (*exchange->escaped)[0] : -1);

                 (int) (uchar) (*exchange->line_term)[0] : INT_MAX);

    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,

#define NEED_ESCAPING(x) ((int) (uchar) (x) == escape_char    || \

                          (enclosed ? (int) (uchar) (x) == field_sep_char      \

                                    : (int) (uchar) (x) == field_term_char) || \

                          (int) (uchar) (x) == line_sep_char  || \

  uint used_length=0,items_left=items.elements;

  if (my_b_write(&cache,(uchar*) exchange->line_start->ptr(),

      if (my_b_write(&cache,(uchar*) exchange->enclosed->ptr(),

          if (my_b_write(&cache,(uchar*) null_buff,2))

        else if (my_b_write(&cache,(uchar*) "NULL",4))

        used_length=min(res->length(),item->max_length);

        CHARSET_INFO *res_charset= res->charset();

        CHARSET_INFO *character_set_client= thd->variables.

                                            character_set_client;

            mysql> LOAD DATA INFILE 'dump.txt' INTO TABLE t1;

                my_mbcharlen(character_set_client, (uchar) *pos) == 2 &&