/* Copyright (C) 2012-2018 Kentoku Shiba

  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; version 2 of the License.

  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.

  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */

#define MYSQL_SERVER 1
#include <my_global.h>
#include "mysql_version.h"
#include "spd_environ.h"
#if MYSQL_VERSION_ID < 50500
#include "mysql_priv.h"
#include <mysql/plugin.h>
#else
#include "sql_priv.h"
#include "probes_mysql.h"
#include "sql_analyse.h"
#endif

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
#include "spd_err.h"
#include "spd_param.h"
#include "spd_db_include.h"
#include "spd_include.h"
#include "spd_db_handlersocket.h"
#include "ha_spider.h"
#include "spd_db_conn.h"
#include "spd_trx.h"
#include "spd_conn.h"
#include "spd_malloc.h"

extern handlerton *spider_hton_ptr;
extern HASH spider_open_connections;
extern HASH spider_ipport_conns;
extern SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE];
extern const char spider_dig_upper[];

#define SPIDER_SQL_INTERVAL_STR " + interval "
#define SPIDER_SQL_INTERVAL_LEN (sizeof(SPIDER_SQL_INTERVAL_STR) - 1)
#define SPIDER_SQL_NEGINTERVAL_STR " - interval "
#define SPIDER_SQL_NEGINTERVAL_LEN (sizeof(SPIDER_SQL_NEGINTERVAL_STR) - 1)

#define SPIDER_SQL_NAME_QUOTE_STR ""
#define SPIDER_SQL_NAME_QUOTE_LEN (sizeof(SPIDER_SQL_NAME_QUOTE_STR) - 1)
static const char *name_quote_str = SPIDER_SQL_NAME_QUOTE_STR;

#define SPIDER_SQL_TYPE_FULL_HS (SPIDER_SQL_TYPE_SELECT_HS | \
  SPIDER_SQL_TYPE_INSERT_HS | SPIDER_SQL_TYPE_UPDATE_HS | \
  SPIDER_SQL_TYPE_DELETE_HS | SPIDER_SQL_TYPE_OTHER_HS)

static uchar SPIDER_SQL_LINESTRING_HEAD_STR[] =
  {0x00,0x00,0x00,0x00,0x01,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00};
#define SPIDER_SQL_LINESTRING_HEAD_LEN sizeof(SPIDER_SQL_LINESTRING_HEAD_STR)

static const char *spider_db_timefunc_interval_str[] =
{
  " year", " quarter", " month", " week", " day",
  " hour", " minute", " second", " microsecond",
  " year_month", " day_hour", " day_minute",
  " day_second", " hour_minute", " hour_second",
  " minute_second", " day_microsecond", " hour_microsecond",
  " minute_microsecond", " second_microsecond"
};

static SPIDER_HS_STRING_REF spider_null_string_ref = SPIDER_HS_STRING_REF();

int spider_handlersocket_init()
{
  DBUG_ENTER("spider_handlersocket_init");
  DBUG_RETURN(0);
}

int spider_handlersocket_deinit()
{
  DBUG_ENTER("spider_handlersocket_deinit");
  DBUG_RETURN(0);
}

spider_db_share *spider_handlersocket_create_share(
  SPIDER_SHARE *share
) {
  DBUG_ENTER("spider_handlersocket_create_share");
  DBUG_RETURN(new spider_handlersocket_share(share));
}

spider_db_handler *spider_handlersocket_create_handler(
  ha_spider *spider,
  spider_db_share *db_share
) {
  DBUG_ENTER("spider_handlersocket_create_handler");
  DBUG_RETURN(new spider_handlersocket_handler(spider,
    (spider_handlersocket_share *) db_share));
}

SPIDER_DB_CONN *spider_handlersocket_create_conn(
  SPIDER_CONN *conn
) {
  DBUG_ENTER("spider_handlersocket_create_conn");
  DBUG_RETURN(new spider_db_handlersocket(conn));
}

bool spider_handlersocket_support_direct_join(
) {
  DBUG_ENTER("spider_handlersocket_support_direct_join");
  DBUG_RETURN(FALSE);
}

spider_db_handlersocket_util spider_db_handlersocket_utility;

SPIDER_DBTON spider_dbton_handlersocket = {
  0,
  SPIDER_DB_WRAPPER_MYSQL,
  SPIDER_DB_ACCESS_TYPE_NOSQL,
  spider_handlersocket_init,
  spider_handlersocket_deinit,
  spider_handlersocket_create_share,
  spider_handlersocket_create_handler,
  NULL,
  spider_handlersocket_create_conn,
  spider_handlersocket_support_direct_join,
  &spider_db_handlersocket_utility,
  "For communicating using the handlersocket protocol",
  "0.1.0",
  SPIDER_MATURITY_BETA
};

#ifndef HANDLERSOCKET_MYSQL_UTIL
spider_db_hs_string_ref_buffer::spider_db_hs_string_ref_buffer()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::spider_db_hs_string_ref_buffer");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

spider_db_hs_string_ref_buffer::~spider_db_hs_string_ref_buffer()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::~spider_db_hs_string_ref_buffer");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

int spider_db_hs_string_ref_buffer::init()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::init");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

void spider_db_hs_string_ref_buffer::clear()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::clear");
  DBUG_PRINT("info",("spider this=%p", this));
  hs_conds.clear();
  DBUG_VOID_RETURN;
}

int spider_db_hs_string_ref_buffer::push_back(
  SPIDER_HS_STRING_REF &cond
) {
  DBUG_ENTER("spider_db_hs_string_ref_buffer::push_back");
  DBUG_PRINT("info",("spider this=%p", this));
  hs_conds.push_back(cond);
  DBUG_RETURN(0);
}

SPIDER_HS_STRING_REF *spider_db_hs_string_ref_buffer::ptr()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::ptr");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(&hs_conds[0]);
}

uint spider_db_hs_string_ref_buffer::size()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::size");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN((uint) hs_conds.size());
}
#else
spider_db_hs_string_ref_buffer::spider_db_hs_string_ref_buffer() : hs_da_init(FALSE)
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::spider_db_hs_string_ref_buffer");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

spider_db_hs_string_ref_buffer::~spider_db_hs_string_ref_buffer()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::~spider_db_hs_string_ref_buffer");
  DBUG_PRINT("info",("spider this=%p", this));
  if (hs_da_init)
  {
    spider_free_mem_calc(spider_current_trx,
      hs_conds_id, hs_conds.max_element * hs_conds.size_of_element);
    delete_dynamic(&hs_conds);
  }
  DBUG_VOID_RETURN;
}

int spider_db_hs_string_ref_buffer::init()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::init");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!hs_da_init)
  {
    SPD_INIT_DYNAMIC_ARRAY2(&hs_conds, sizeof(SPIDER_HS_STRING_REF),
      NULL, 16, 16, MYF(MY_WME));
    spider_alloc_calc_mem_init(hs_conds, 159);
    spider_alloc_calc_mem(spider_current_trx,
      hs_conds, hs_conds.max_element * hs_conds.size_of_element);
    hs_da_init = TRUE;
  }
  DBUG_RETURN(0);
}

void spider_db_hs_string_ref_buffer::clear()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::clear");
  DBUG_PRINT("info",("spider this=%p", this));
  hs_conds.elements = 0;
  DBUG_VOID_RETURN;
}

int spider_db_hs_string_ref_buffer::push_back(
  SPIDER_HS_STRING_REF &cond
) {
  uint old_elements = hs_conds.max_element;
  DBUG_ENTER("spider_db_hs_string_ref_buffer::push_back");
  DBUG_PRINT("info",("spider this=%p", this));
  if (insert_dynamic(&hs_conds, (uchar *) &cond))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  if (hs_conds.max_element > old_elements)
  {
    spider_alloc_calc_mem(spider_current_trx,
      hs_conds,
      (hs_conds.max_element - old_elements) * hs_conds.size_of_element);
  }
  DBUG_RETURN(0);
}

SPIDER_HS_STRING_REF *spider_db_hs_string_ref_buffer::ptr()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::ptr");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN((SPIDER_HS_STRING_REF *) hs_conds.buffer);
}

uint spider_db_hs_string_ref_buffer::size()
{
  DBUG_ENTER("spider_db_hs_string_ref_buffer::size");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(hs_conds.elements);
}
#endif

spider_db_hs_str_buffer::spider_db_hs_str_buffer() : hs_da_init(FALSE)
{
  DBUG_ENTER("spider_db_hs_str_buffer::spider_db_hs_str_buffer");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

spider_db_hs_str_buffer::~spider_db_hs_str_buffer()
{
  DBUG_ENTER("spider_db_hs_str_buffer::~spider_db_hs_str_buffer");
  DBUG_PRINT("info",("spider this=%p", this));
  if (hs_da_init)
  {
    spider_free_mem_calc(spider_current_trx,
      hs_conds_id, hs_conds.max_element * hs_conds.size_of_element);
    delete_dynamic(&hs_conds);
  }
  DBUG_VOID_RETURN;
}

int spider_db_hs_str_buffer::init()
{
  DBUG_ENTER("spider_db_hs_str_buffer::init");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!hs_da_init)
  {
    SPD_INIT_DYNAMIC_ARRAY2(&hs_conds, sizeof(spider_string *),
      NULL, 16, 16, MYF(MY_WME));
    spider_alloc_calc_mem_init(hs_conds, 160);
    spider_alloc_calc_mem(spider_current_trx,
      hs_conds, hs_conds.max_element * hs_conds.size_of_element);
    hs_da_init = TRUE;
  }
  DBUG_RETURN(0);
}

void spider_db_hs_str_buffer::clear()
{
  uint i;
  spider_string *element;
  DBUG_ENTER("spider_db_hs_str_buffer::clear");
  DBUG_PRINT("info",("spider this=%p", this));
  for (i = 0; i < hs_conds.elements; i++)
  {
    get_dynamic(&hs_conds, (uchar *) &element, i);
    element->free();
    spider_free(spider_current_trx, element, MYF(0));
  }
  hs_conds.elements = 0;
  DBUG_VOID_RETURN;
}

spider_string *spider_db_hs_str_buffer::add(
  uint *strs_pos,
  const char *str,
  uint str_len
) {
  spider_string *element;
  DBUG_ENTER("spider_db_hs_str_buffer::add");
  DBUG_PRINT("info",("spider this=%p", this));
  if (hs_conds.elements <= *strs_pos + 1)
  {
    if (!(element = (spider_string *) spider_malloc(spider_current_trx, 8,
      sizeof(spider_string), MYF(MY_WME | MY_ZEROFILL))))
      DBUG_RETURN(NULL);
    element->init_calc_mem(98);
    element->set_charset(&my_charset_bin);
    if ((element->reserve(str_len + 1)))
    {
      spider_free(spider_current_trx, element, MYF(0));
      DBUG_RETURN(NULL);
    }
    element->q_append(str, str_len);
    uint old_elements = hs_conds.max_element;
    if (insert_dynamic(&hs_conds, (uchar *) &element))
    {
      element->free();
      spider_free(spider_current_trx, element, MYF(0));
      DBUG_RETURN(NULL);
    }
    if (hs_conds.max_element > old_elements)
    {
      spider_alloc_calc_mem(spider_current_trx,
        hs_conds,
        (hs_conds.max_element - old_elements) *
        hs_conds.size_of_element);
    }
  } else {
    element = ((spider_string **) hs_conds.buffer)[*strs_pos];
    element->length(0);
    if ((element->reserve(str_len + 1)))
      DBUG_RETURN(NULL);
    element->q_append(str, str_len);
  }
  (*strs_pos)++;
  DBUG_RETURN(element);
}

spider_db_handlersocket_row::spider_db_handlersocket_row() :
  spider_db_row(spider_dbton_handlersocket.dbton_id),
  hs_row(NULL), field_count(0), row_size(0), cloned(FALSE)
{
  DBUG_ENTER("spider_db_handlersocket_row::spider_db_handlersocket_row");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

spider_db_handlersocket_row::~spider_db_handlersocket_row()
{
  DBUG_ENTER("spider_db_handlersocket_row::~spider_db_handlersocket_row");
  DBUG_PRINT("info",("spider this=%p", this));
  if (cloned)
  {
    spider_free(spider_current_trx, hs_row_first, MYF(0));
  }
  DBUG_VOID_RETURN;
}

int spider_db_handlersocket_row::store_to_field(
  Field *field,
  CHARSET_INFO *access_charset
) {
  DBUG_ENTER("spider_db_handlersocket_row::store_to_field");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!hs_row->begin())
  {
    DBUG_PRINT("info", ("spider field is null"));
    field->set_null();
    field->reset();
  } else {
#ifndef DBUG_OFF
    char buf[MAX_FIELD_WIDTH];
    spider_string tmp_str(buf, MAX_FIELD_WIDTH, field->charset());
    tmp_str.init_calc_mem(119);
    tmp_str.length(0);
    tmp_str.append(hs_row->begin(), hs_row->size(), &my_charset_bin);
    DBUG_PRINT("info", ("spider val=%s", tmp_str.c_ptr_safe()));
#endif
    field->set_notnull();
    if (field->flags & BLOB_FLAG)
    {
      DBUG_PRINT("info", ("spider blob field"));
      ((Field_blob *)field)->set_ptr(
        hs_row->size(), (uchar *) hs_row->begin());
    } else
      field->store(hs_row->begin(), hs_row->size(), &my_charset_bin);
  }
  DBUG_RETURN(0);
}

int spider_db_handlersocket_row::append_to_str(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket_row::append_to_str");
  DBUG_PRINT("info",("spider this=%p", this));
  if (str->reserve(hs_row->size()))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  str->q_append(hs_row->begin(), hs_row->size());
  DBUG_RETURN(0);
}

int spider_db_handlersocket_row::append_escaped_to_str(
  spider_string *str,
  uint dbton_id
) {
  DBUG_ENTER("spider_db_handlersocket_row::append_escaped_to_str");
  DBUG_PRINT("info",("spider this=%p", this));
  spider_string tmp_str(hs_row->begin(), hs_row->size() + 1, &my_charset_bin);
  tmp_str.init_calc_mem(172);
  tmp_str.length(hs_row->size());
  if (str->reserve(hs_row->size() * 2 + 2))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  spider_dbton[dbton_id].db_util->append_escaped_util(str, tmp_str.get_str());
  str->mem_calc();
  DBUG_RETURN(0);
}

void spider_db_handlersocket_row::first()
{
  DBUG_ENTER("spider_db_handlersocket_row::first");
  DBUG_PRINT("info",("spider this=%p", this));
  hs_row = hs_row_first;
  DBUG_VOID_RETURN;
}

void spider_db_handlersocket_row::next()
{
  DBUG_ENTER("spider_db_handlersocket_row::next");
  DBUG_PRINT("info",("spider this=%p", this));
  hs_row++;
  DBUG_VOID_RETURN;
}

bool spider_db_handlersocket_row::is_null()
{
  DBUG_ENTER("spider_db_handlersocket_row::is_null");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(!hs_row->begin());
}

int spider_db_handlersocket_row::val_int()
{
  DBUG_ENTER("spider_db_handlersocket_row::val_int");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(atoi(hs_row->begin()));
}

double spider_db_handlersocket_row::val_real()
{
  DBUG_ENTER("spider_db_handlersocket_row::val_real");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(hs_row->begin() ? my_atof(hs_row->begin()) : 0.0);
}

my_decimal *spider_db_handlersocket_row::val_decimal(
  my_decimal *decimal_value,
  CHARSET_INFO *access_charset
) {
  DBUG_ENTER("spider_db_handlersocket_row::val_decimal");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!hs_row->begin())
    DBUG_RETURN(NULL);

#ifdef SPIDER_HAS_DECIMAL_OPERATION_RESULTS_VALUE_TYPE
  decimal_operation_results(str2my_decimal(0, hs_row->begin(), hs_row->size(),
    access_charset, decimal_value), "", "");
#else
  decimal_operation_results(str2my_decimal(0, hs_row->begin(), hs_row->size(),
    access_charset, decimal_value));
#endif

  DBUG_RETURN(decimal_value);
}

SPIDER_DB_ROW *spider_db_handlersocket_row::clone()
{
  spider_db_handlersocket_row *clone_row;
  char *tmp_char;
  uint i;
  DBUG_ENTER("spider_db_handlersocket_row::clone");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!(clone_row = new spider_db_handlersocket_row(dbton_id)))
  {
    DBUG_RETURN(NULL);
  }
  if (!spider_bulk_malloc(spider_current_trx, 169, MYF(MY_WME),
    &clone_row->hs_row, (uint) (sizeof(SPIDER_HS_STRING_REF) * field_count),
    &tmp_char, (uint) (row_size),
    NullS)
  ) {
    delete clone_row;
    DBUG_RETURN(NULL);
  }
  for (i = 0; i < field_count; i++)
  {
    memcpy(tmp_char, hs_row_first[i].begin(), hs_row_first[i].size());
    clone_row->hs_row[i].set(tmp_char, hs_row_first[i].size());
    tmp_char += hs_row_first[i].size();
  }
  clone_row->hs_row_first = clone_row->hs_row;
  clone_row->cloned = TRUE;;
  clone_row->row_size = row_size;;
  DBUG_RETURN(NULL);
}

int spider_db_handlersocket_row::store_to_tmp_table(
  TABLE *tmp_table,
  spider_string *str
) {
  uint i;
  SPIDER_HS_STRING_REF *tmp_hs_row = hs_row;
  DBUG_ENTER("spider_db_handlersocket_row::store_to_tmp_table");
  DBUG_PRINT("info",("spider this=%p", this));
  str->length(0);
  for (i = 0; i < field_count; i++)
  {
    if (tmp_hs_row->begin())
    {
      if (str->reserve(tmp_hs_row->size()))
      {
        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
      }
      str->q_append(tmp_hs_row->begin(), tmp_hs_row->size());
    }
    tmp_hs_row++;
  }
  tmp_table->field[0]->set_notnull();
  tmp_table->field[0]->store(
    (const char *) hs_row,
    sizeof(SPIDER_HS_STRING_REF) * field_count, &my_charset_bin);
  tmp_table->field[1]->set_notnull();
  tmp_table->field[1]->store(
    str->ptr(), str->length(), &my_charset_bin);
  tmp_table->field[2]->set_null();
  DBUG_RETURN(tmp_table->file->ha_write_row(tmp_table->record[0]));
}

uint spider_db_handlersocket_row::get_byte_size()
{
  DBUG_ENTER("spider_db_handlersocket_row::get_byte_size");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(row_size);
}


spider_db_handlersocket_result_buffer::spider_db_handlersocket_result_buffer(
) : spider_db_result_buffer()
{
  DBUG_ENTER("spider_db_handlersocket_result_buffer::spider_db_handlersocket_result_buffer");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

spider_db_handlersocket_result_buffer::~spider_db_handlersocket_result_buffer()
{
  DBUG_ENTER(
    "spider_db_handlersocket_result_buffer::~spider_db_handlersocket_result_buffer");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

void spider_db_handlersocket_result_buffer::clear()
{
  DBUG_ENTER("spider_db_handlersocket_result_buffer::clear");
  DBUG_PRINT("info",("spider this=%p", this));
  hs_result.readbuf.clear();
  DBUG_VOID_RETURN;
}

bool spider_db_handlersocket_result_buffer::check_size(
  longlong size
) {
  DBUG_ENTER("spider_db_handlersocket_result_buffer::check_size");
  DBUG_PRINT("info",("spider this=%p", this));
  if ((uint) hs_result.readbuf.real_size() > size)
  {
    hs_result.readbuf.real_free();
    DBUG_RETURN(TRUE);
  }
  DBUG_RETURN(FALSE);
}

spider_db_handlersocket_result::spider_db_handlersocket_result(
  SPIDER_DB_CONN *in_db_conn
) : spider_db_result(in_db_conn), row(in_db_conn->dbton_id)
{
  DBUG_ENTER("spider_db_handlersocket_result::spider_db_handlersocket_result");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

spider_db_handlersocket_result::~spider_db_handlersocket_result()
{
  DBUG_ENTER(
    "spider_db_handlersocket_result::~spider_db_handlersocket_result");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

bool spider_db_handlersocket_result::has_result()
{
  DBUG_ENTER("spider_db_handlersocket_result::has_result");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(((*hs_conn_p)->get_response_end_offset() > 0));
}

void spider_db_handlersocket_result::free_result()
{
  DBUG_ENTER("spider_db_handlersocket_result::free_result");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  if ((*hs_conn_p)->get_response_end_offset() > 0)
  {
    (*hs_conn_p)->response_buf_remove();
    if ((*hs_conn_p)->get_error_code())
    {
      DBUG_PRINT("info",("spider hs %d %s",
        (*hs_conn_p)->get_error_code(),
        (*hs_conn_p)->get_error().ptr()));
      (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
    }
    DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
      (*hs_conn_p)->get_num_req_bufd()));
    DBUG_PRINT("info",("spider hs num_req_sent=%zu",
      (*hs_conn_p)->get_num_req_sent()));
    DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
      (*hs_conn_p)->get_num_req_rcvd()));
    DBUG_PRINT("info",("spider hs response_end_offset=%zu",
      (*hs_conn_p)->get_response_end_offset()));
  }
  DBUG_VOID_RETURN;
}

SPIDER_DB_ROW *spider_db_handlersocket_result::current_row()
{
  DBUG_ENTER("spider_db_handlersocket_result::current_row");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN((SPIDER_DB_ROW *) row.clone());
}

SPIDER_DB_ROW *spider_db_handlersocket_result::fetch_row()
{
  DBUG_ENTER("spider_db_handlersocket_result::fetch_row");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!(row.hs_row = (SPIDER_HS_STRING_REF *)
    (*hs_conn_p)->get_next_row()))
  {
    store_error_num = HA_ERR_END_OF_FILE;
    DBUG_RETURN(NULL);
  }
  row.field_count = field_count;
  row.hs_row_first = row.hs_row;
  row.row_size = (*hs_conn_p)->get_row_size();
  DBUG_RETURN((SPIDER_DB_ROW *) &row);
}

SPIDER_DB_ROW *spider_db_handlersocket_result::fetch_row_from_result_buffer(
  spider_db_result_buffer *spider_res_buf
) {
  spider_db_handlersocket_result_buffer *hs_res_buf;
  DBUG_ENTER("spider_db_handlersocket_result::fetch_row_from_result_buffer");
  DBUG_PRINT("info",("spider this=%p", this));
  hs_res_buf = (spider_db_handlersocket_result_buffer *) spider_res_buf;
  if (!(row.hs_row = (SPIDER_HS_STRING_REF *)
    (*hs_conn_p)->get_next_row_from_result(hs_res_buf->hs_result)))
  {
    store_error_num = HA_ERR_END_OF_FILE;
    DBUG_RETURN(NULL);
  }
  row.field_count = field_count;
  row.hs_row_first = row.hs_row;
  row.row_size = (*hs_conn_p)->get_row_size_from_result(hs_res_buf->hs_result);
  DBUG_RETURN((SPIDER_DB_ROW *) &row);
}

SPIDER_DB_ROW *spider_db_handlersocket_result::fetch_row_from_tmp_table(
  TABLE *tmp_table
) {
  uint i;
  spider_string tmp_str1, tmp_str2;
  const char *row_ptr;
  SPIDER_HS_STRING_REF *tmp_hs_row;
  uint field_count;
  DBUG_ENTER("spider_db_handlersocket_result::fetch_row_from_tmp_table");
  DBUG_PRINT("info",("spider this=%p", this));
  tmp_str1.init_calc_mem(171);
  tmp_str2.init_calc_mem(173);
  tmp_table->field[0]->val_str(tmp_str1.get_str());
  tmp_table->field[1]->val_str(tmp_str2.get_str());
  tmp_str1.mem_calc();
  tmp_str2.mem_calc();
  row_ptr = tmp_str2.ptr();
  tmp_hs_row = (SPIDER_HS_STRING_REF *) tmp_str1.ptr();
  field_count = tmp_str1.length() / sizeof(SPIDER_HS_STRING_REF);
  row.hs_row = tmp_hs_row;
  row.field_count = field_count;
  row.hs_row_first = row.hs_row;
  for (i = 0; i < field_count; i++)
  {
    if (tmp_hs_row->begin())
    {
      uint length = tmp_hs_row->size();
      tmp_hs_row->set(row_ptr, length);
      row_ptr += length;
    }
    tmp_hs_row++;
  }
  row.row_size = row_ptr - tmp_str2.ptr();
  DBUG_RETURN((SPIDER_DB_ROW *) &row);
}

int spider_db_handlersocket_result::fetch_table_status(
  int mode,
  ha_statistics &stat
) {
  DBUG_ENTER("spider_db_handlersocket_result::fetch_table_status");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_result::fetch_table_records(
  int mode,
  ha_rows &records
) {
  DBUG_ENTER("spider_db_handlersocket_result::fetch_table_records");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_result::fetch_table_cardinality(
  int mode,
  TABLE *table,
  longlong *cardinality,
  uchar *cardinality_upd,
  int bitmap_size
) {
  DBUG_ENTER("spider_db_handlersocket_result::fetch_table_cardinality");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_result::fetch_table_mon_status(
  int &status
) {
  DBUG_ENTER("spider_db_handlersocket_result::fetch_table_mon_status");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

longlong spider_db_handlersocket_result::num_rows()
{
  DBUG_ENTER("spider_db_handlersocket_result::num_rows");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN((longlong) 0);
}

uint spider_db_handlersocket_result::num_fields()
{
  DBUG_ENTER("spider_db_handlersocket_result::num_fields");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(field_count);
}

void spider_db_handlersocket_result::move_to_pos(
  longlong pos
) {
  DBUG_ENTER("spider_db_handlersocket_result::move_to_pos");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_VOID_RETURN;
}

int spider_db_handlersocket_result::get_errno()
{
  DBUG_ENTER("spider_db_handlersocket_result::get_errno");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info",("spider store_error_num=%d", store_error_num));
  DBUG_RETURN(store_error_num);
}

#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int spider_db_handlersocket_result::fetch_columns_for_discover_table_structure(
  spider_string *str,
  CHARSET_INFO *access_charset
) {
  DBUG_ENTER("spider_db_handlersocket_result::fetch_columns_for_discover_table_structure");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(HA_ERR_WRONG_COMMAND);
}

int spider_db_handlersocket_result::fetch_index_for_discover_table_structure(
  spider_string *str,
  CHARSET_INFO *access_charset
) {
  DBUG_ENTER("spider_db_handlersocket_result::fetch_index_for_discover_table_structure");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(HA_ERR_WRONG_COMMAND);
}

int spider_db_handlersocket_result::fetch_table_for_discover_table_structure(
  spider_string *str,
  SPIDER_SHARE *spider_share,
  CHARSET_INFO *access_charset
) {
  DBUG_ENTER("spider_db_handlersocket_result::fetch_table_for_discover_table_structure");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(HA_ERR_WRONG_COMMAND);
}
#endif

spider_db_handlersocket::spider_db_handlersocket(
  SPIDER_CONN *conn
) : spider_db_conn(conn),
  handler_open_array_inited(FALSE),
  request_key_req_first(NULL),
  request_key_req_last(NULL),
  request_key_snd_first(NULL),
  request_key_snd_last(NULL),
  request_key_reuse_first(NULL),
  request_key_reuse_last(NULL)
{
  DBUG_ENTER("spider_db_handlersocket::spider_db_handlersocket");
  DBUG_PRINT("info",("spider this=%p", this));
#ifndef HANDLERSOCKET_MYSQL_UTIL
#else
  hs_conn = NULL;
#endif
  DBUG_VOID_RETURN;
}

spider_db_handlersocket::~spider_db_handlersocket()
{
  st_spider_db_request_key *tmp_request_key;
  DBUG_ENTER("spider_db_handlersocket::~spider_db_handlersocket");
  DBUG_PRINT("info",("spider this=%p", this));
  if (handler_open_array_inited)
  {
    reset_opened_handler();
    spider_free_mem_calc(spider_current_trx,
      handler_open_array_id,
      handler_open_array.max_element *
      handler_open_array.size_of_element);
    delete_dynamic(&handler_open_array);
  }
  while (request_key_req_first)
  {
    tmp_request_key = request_key_req_first->next;
    spider_free(spider_current_trx, request_key_req_first, MYF(0));
    request_key_req_first = tmp_request_key;
  }
  while (request_key_snd_first)
  {
    tmp_request_key = request_key_snd_first->next;
    spider_free(spider_current_trx, request_key_snd_first, MYF(0));
    request_key_snd_first = tmp_request_key;
  }
  while (request_key_reuse_first)
  {
    tmp_request_key = request_key_reuse_first->next;
    spider_free(spider_current_trx, request_key_reuse_first, MYF(0));
    request_key_reuse_first = tmp_request_key;
  }
  DBUG_VOID_RETURN;
}

int spider_db_handlersocket::init()
{
  DBUG_ENTER("spider_db_handlersocket::init");
  DBUG_PRINT("info",("spider this=%p", this));
  if (
    SPD_INIT_DYNAMIC_ARRAY2(&handler_open_array,
      sizeof(SPIDER_LINK_FOR_HASH *), NULL, 16, 16, MYF(MY_WME))
  ) {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
  spider_alloc_calc_mem_init(handler_open_array, 79);
  spider_alloc_calc_mem(spider_current_trx,
    handler_open_array,
    handler_open_array.max_element *
    handler_open_array.size_of_element);
  handler_open_array_inited = TRUE;
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::is_connected()
{
  DBUG_ENTER("spider_db_handlersocket::is_connected");
  DBUG_PRINT("info",("spider this=%p", this));
#ifndef HANDLERSOCKET_MYSQL_UTIL
  DBUG_RETURN(hs_conn.operator->());
#else
  DBUG_RETURN(hs_conn);
#endif
}

void spider_db_handlersocket::bg_connect()
{
  DBUG_ENTER("spider_db_handlersocket::bg_connect");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

int spider_db_handlersocket::connect(
  char *tgt_host,
  char *tgt_username,
  char *tgt_password,
  long tgt_port,
  char *tgt_socket,
  char *server_name,
  int connect_retry_count,
  longlong connect_retry_interval
) {
  DBUG_ENTER("spider_db_handlersocket::connect");
  DBUG_PRINT("info",("spider this=%p", this));
  SPIDER_HS_SOCKARGS sockargs;
  sockargs.timeout = conn->connect_timeout;
  sockargs.recv_timeout = conn->net_read_timeout;
  sockargs.send_timeout = conn->net_write_timeout;
  if (conn->hs_sock)
  {
    sockargs.family = AF_UNIX;
    sockargs.set_unix_domain(conn->hs_sock);
  } else {
    char port_str[6];
    my_sprintf(port_str, (port_str, "%05ld", conn->hs_port));
    if (sockargs.resolve(conn->tgt_host, port_str) != 0)
    {
      my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
        conn->tgt_host);
      DBUG_RETURN(ER_CONNECT_TO_FOREIGN_DATA_SOURCE);
    }
  }
#ifndef HANDLERSOCKET_MYSQL_UTIL
  if (!(hs_conn.operator->()))
#else
  if (!(hs_conn))
#endif
  {
    hs_conn = SPIDER_HS_CONN_CREATE(sockargs);
  } else {
    hs_conn->reconnect();
    spider_db_hs_request_buf_reset(conn);
  }
#ifndef HANDLERSOCKET_MYSQL_UTIL
  if (!(hs_conn.operator->()))
#else
  if (!(hs_conn))
#endif
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  while (hs_conn->get_error_code())
  {
    THD *thd = current_thd;
    if (
      !connect_retry_count ||
      (thd && thd->killed)
    ) {
      my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
        conn->tgt_host);
      DBUG_RETURN(ER_CONNECT_TO_FOREIGN_DATA_SOURCE);
    }
    connect_retry_count--;
    my_sleep((ulong) connect_retry_interval);
    hs_conn->reconnect();
  }
  reset_request_key_req();
  reset_request_key_snd();
  DBUG_RETURN(0);
}

int spider_db_handlersocket::ping()
{
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::ping");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  if ((*hs_conn_p)->reconnect())
  {
    DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
      (*hs_conn_p)->get_num_req_bufd()));
    DBUG_PRINT("info",("spider hs num_req_sent=%zu",
      (*hs_conn_p)->get_num_req_sent()));
    DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
      (*hs_conn_p)->get_num_req_rcvd()));
    DBUG_PRINT("info",("spider hs response_end_offset=%zu",
      (*hs_conn_p)->get_response_end_offset()));
    DBUG_RETURN(ER_SPIDER_HS_NUM);
  }
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));

  reset_request_key_req();
  reset_request_key_snd();
  conn->opened_handlers = 0;
  conn->db_conn->reset_opened_handler();
  ++conn->connection_id;
  DBUG_RETURN(0);
}

void spider_db_handlersocket::bg_disconnect()
{
  DBUG_ENTER("spider_db_handlersocket::bg_disconnect");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

void spider_db_handlersocket::disconnect()
{
  DBUG_ENTER("spider_db_handlersocket::disconnect");
  DBUG_PRINT("info",("spider this=%p", this));
#ifndef HANDLERSOCKET_MYSQL_UTIL
  if (hs_conn.operator->())
#else
  DBUG_PRINT("info",("spider hs_conn=%p", hs_conn));
  if (hs_conn)
#endif
  {
    hs_conn->close();
#ifndef HANDLERSOCKET_MYSQL_UTIL
    SPIDER_HS_CONN tmp_hs_conn;
    tmp_hs_conn = hs_conn;
#else
    delete hs_conn;
    hs_conn = NULL;
#endif
  }
  DBUG_VOID_RETURN;
}

int spider_db_handlersocket::set_net_timeout()
{
  DBUG_ENTER("spider_db_handlersocket::set_net_timeout");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(hs_conn->set_timeout(
    conn->net_write_timeout,
    conn->net_read_timeout
  ));
}

int spider_db_handlersocket::exec_query(
  const char *query,
  uint length,
  int quick_mode
) {
  DBUG_ENTER("spider_db_handlersocket::query");
  DBUG_PRINT("info",("spider this=%p", this));
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
#ifndef HANDLERSOCKET_MYSQL_UTIL
  DBUG_PRINT("info", ("spider hs_conn %p", hs_conn.operator->()));
#else
  DBUG_PRINT("info", ("spider hs_conn %p", hs_conn));
#endif
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  if (spider_param_general_log())
  {
    const char *tgt_str = conn->hs_sock ? conn->hs_sock : conn->tgt_host;
    uint32 tgt_len = strlen(tgt_str);
    spider_string tmp_query_str((*hs_conn_p)->get_writebuf_size() +
      conn->tgt_wrapper_length +
      tgt_len + (SPIDER_SQL_SPACE_LEN * 2));
    tmp_query_str.init_calc_mem(231);
    tmp_query_str.length(0);
    tmp_query_str.q_append(conn->tgt_wrapper, conn->tgt_wrapper_length);
    tmp_query_str.q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
    tmp_query_str.q_append(tgt_str, tgt_len);
    tmp_query_str.q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
    tmp_query_str.q_append((*hs_conn_p)->get_writebuf_begin(),
      (*hs_conn_p)->get_writebuf_size());
    general_log_write(current_thd, COM_QUERY, tmp_query_str.ptr(),
      tmp_query_str.length());
  }
  if ((*hs_conn_p)->request_send() < 0)
  {
    DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
      (*hs_conn_p)->get_num_req_bufd()));
    DBUG_PRINT("info",("spider hs num_req_sent=%zu",
      (*hs_conn_p)->get_num_req_sent()));
    DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
      (*hs_conn_p)->get_num_req_rcvd()));
    DBUG_PRINT("info",("spider hs response_end_offset=%zu",
      (*hs_conn_p)->get_response_end_offset()));
    DBUG_RETURN(ER_SPIDER_HS_NUM);
  }
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  move_request_key_to_snd();
  DBUG_RETURN(0);
}

int spider_db_handlersocket::get_errno()
{
  DBUG_ENTER("spider_db_handlersocket::get_errno");
  DBUG_PRINT("info",("spider this=%p", this));
  stored_error = hs_conn->get_error_code();
  DBUG_PRINT("info",("spider stored_error=%d", stored_error));
  DBUG_RETURN(stored_error);
}

const char *spider_db_handlersocket::get_error()
{
  const char *error_ptr;
  DBUG_ENTER("spider_db_handlersocket::get_error");
  DBUG_PRINT("info",("spider this=%p", this));
#ifndef HANDLERSOCKET_MYSQL_UTIL
  error_ptr = hs_conn->get_error().c_str();
#else
  error_ptr = hs_conn->get_error().c_ptr();
#endif
  DBUG_PRINT("info",("spider error=%s", error_ptr));
  DBUG_RETURN(error_ptr);
}

bool spider_db_handlersocket::is_server_gone_error(
  int error_num
) {
  bool server_gone;
  DBUG_ENTER("spider_db_handlersocket::is_server_gone_error");
  DBUG_PRINT("info",("spider this=%p", this));
  server_gone = (hs_conn->get_error_code() < 0);
  DBUG_PRINT("info",("spider server_gone=%s", server_gone ? "TRUE" : "FALSE"));
  DBUG_RETURN(server_gone);
}

bool spider_db_handlersocket::is_dup_entry_error(
  int error_num
) {
  bool dup_entry;
  DBUG_ENTER("spider_db_handlersocket::is_dup_entry_error");
  DBUG_PRINT("info",("spider this=%p", this));
#ifndef HANDLERSOCKET_MYSQL_UTIL
  const char *c_str = hs_conn->get_error().c_str();
#else
  const char *c_str = hs_conn->get_error().c_ptr_safe();
#endif
  dup_entry =
    (
      c_str[0] == '1' &&
      c_str[1] == '2' &&
      c_str[2] == '1' &&
      c_str[3] == '\0'
    );
  DBUG_PRINT("info",("spider dup_entry=%s", dup_entry ? "TRUE" : "FALSE"));
  DBUG_RETURN(dup_entry);
}

bool spider_db_handlersocket::is_xa_nota_error(
  int error_num
) {
  bool xa_nota;
  DBUG_ENTER("spider_db_handlersocket::is_xa_nota_error");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  xa_nota = (stored_error == ER_XAER_NOTA);
  DBUG_PRINT("info",("spider xa_nota=%s", xa_nota ? "TRUE" : "FALSE"));
  DBUG_RETURN(xa_nota);
}

spider_db_result *spider_db_handlersocket::store_result(
  spider_db_result_buffer **spider_res_buf,
  st_spider_db_request_key *request_key,
  int *error_num
) {
  int internal_error;
  spider_db_handlersocket_result *result;
  spider_db_handlersocket_result_buffer *hs_res_buf;
  DBUG_ENTER("spider_db_handlersocket::store_result");
  DBUG_PRINT("info",("spider this=%p", this));
  if (*spider_res_buf)
  {
    hs_res_buf = (spider_db_handlersocket_result_buffer *) *spider_res_buf;
  } else {
    if (!(hs_res_buf = new spider_db_handlersocket_result_buffer()))
    {
      *error_num = HA_ERR_OUT_OF_MEM;
      DBUG_RETURN(NULL);
    }
    *spider_res_buf = (spider_db_result_buffer *) hs_res_buf;
  }
  hs_res_buf->clear();
  if (!(result = new spider_db_handlersocket_result(this)))
  {
    *error_num = HA_ERR_OUT_OF_MEM;
    DBUG_RETURN(NULL);
  }
  *error_num = 0;
  result->hs_conn_p = &hs_conn;
  size_t num_fields;
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  if (request_key)
  {
    int tmp_res, tmp_err = (*hs_conn_p)->get_error_code();
    while ((tmp_res = check_request_key(request_key)) == 1)
    {
      DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
        (*hs_conn_p)->get_num_req_bufd()));
      DBUG_PRINT("info",("spider hs num_req_sent=%zu",
        (*hs_conn_p)->get_num_req_sent()));
      DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
        (*hs_conn_p)->get_num_req_rcvd()));
      DBUG_PRINT("info",("spider hs response_end_offset=%zu",
        (*hs_conn_p)->get_response_end_offset()));
      if ((internal_error = (*hs_conn_p)->response_recv(num_fields)))
      {
        if (!tmp_err && internal_error > 0)
        {
          (*hs_conn_p)->clear_error();
        } else {
          (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
#ifndef DBUG_OFF
          if ((*hs_conn_p)->get_response_end_offset() > 0 &&
            (*hs_conn_p)->get_readbuf_begin())
          {
            char tmp_buf[MAX_FIELD_WIDTH];
            String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
            tmp_str.length(0);
            tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
              (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
            DBUG_PRINT("info",("spider hs readbuf01 size=%zu str=%s",
              (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
          }
#endif
          DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
            (*hs_conn_p)->get_num_req_bufd()));
          DBUG_PRINT("info",("spider hs num_req_sent=%zu",
            (*hs_conn_p)->get_num_req_sent()));
          DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
            (*hs_conn_p)->get_num_req_rcvd()));
          DBUG_PRINT("info",("spider hs response_end_offset=%zu",
            (*hs_conn_p)->get_response_end_offset()));
          if (internal_error > 0)
          {
            (*hs_conn_p)->response_buf_remove();
            if ((*hs_conn_p)->get_error_code())
            {
              DBUG_PRINT("info",("spider hs %d %s",
                (*hs_conn_p)->get_error_code(),
                (*hs_conn_p)->get_error().ptr()));
              (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
            }
            DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
              (*hs_conn_p)->get_num_req_bufd()));
            DBUG_PRINT("info",("spider hs num_req_sent=%zu",
              (*hs_conn_p)->get_num_req_sent()));
            DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
              (*hs_conn_p)->get_num_req_rcvd()));
            DBUG_PRINT("info",("spider hs response_end_offset=%zu",
              (*hs_conn_p)->get_response_end_offset()));
            (*hs_conn_p)->clear_error();
          }
          delete result;
          DBUG_RETURN(NULL);
        }
      }
      DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
        (*hs_conn_p)->get_num_req_bufd()));
      DBUG_PRINT("info",("spider hs num_req_sent=%zu",
        (*hs_conn_p)->get_num_req_sent()));
      DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
        (*hs_conn_p)->get_num_req_rcvd()));
      DBUG_PRINT("info",("spider hs response_end_offset=%zu",
        (*hs_conn_p)->get_response_end_offset()));
      (*hs_conn_p)->response_buf_remove();
      DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
        (*hs_conn_p)->get_num_req_bufd()));
      DBUG_PRINT("info",("spider hs num_req_sent=%zu",
        (*hs_conn_p)->get_num_req_sent()));
      DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
        (*hs_conn_p)->get_num_req_rcvd()));
      DBUG_PRINT("info",("spider hs response_end_offset=%zu",
        (*hs_conn_p)->get_response_end_offset()));
    }
    if (tmp_res == -1)
    {
      DBUG_PRINT("info",("spider ER_SPIDER_REQUEST_KEY_NUM"));
      *error_num = ER_SPIDER_REQUEST_KEY_NUM;
      DBUG_RETURN(NULL);
    }
  }
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  if (
    (internal_error = (*hs_conn_p)->response_recv(num_fields)) ||
    (*error_num = (*hs_conn_p)->get_result(hs_res_buf->hs_result))
  ) {
    if (*error_num)
    {
      *error_num = HA_ERR_OUT_OF_MEM;
    }
    (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
#ifndef DBUG_OFF
    if ((*hs_conn_p)->get_response_end_offset() > 0 &&
      (*hs_conn_p)->get_readbuf_begin())
    {
      char tmp_buf[MAX_FIELD_WIDTH];
      String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
      tmp_str.length(0);
      tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
        (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
      DBUG_PRINT("info",("spider hs readbuf01 size=%zu str=%s",
        (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
    }
#endif
    DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
      (*hs_conn_p)->get_num_req_bufd()));
    DBUG_PRINT("info",("spider hs num_req_sent=%zu",
      (*hs_conn_p)->get_num_req_sent()));
    DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
      (*hs_conn_p)->get_num_req_rcvd()));
    DBUG_PRINT("info",("spider hs response_end_offset=%zu",
      (*hs_conn_p)->get_response_end_offset()));
    if (internal_error > 0)
    {
      (*hs_conn_p)->response_buf_remove();
      if ((*hs_conn_p)->get_error_code())
      {
        DBUG_PRINT("info",("spider hs %d %s",
          (*hs_conn_p)->get_error_code(),
          (*hs_conn_p)->get_error().ptr()));
        (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
      }
      DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
        (*hs_conn_p)->get_num_req_bufd()));
      DBUG_PRINT("info",("spider hs num_req_sent=%zu",
        (*hs_conn_p)->get_num_req_sent()));
      DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
        (*hs_conn_p)->get_num_req_rcvd()));
      DBUG_PRINT("info",("spider hs response_end_offset=%zu",
        (*hs_conn_p)->get_response_end_offset()));
    }
    delete result;
    DBUG_RETURN(NULL);
  }
#ifndef DBUG_OFF
  if ((*hs_conn_p)->get_response_end_offset() > 0 &&
    (*hs_conn_p)->get_readbuf_begin())
  {
    char tmp_buf[MAX_FIELD_WIDTH];
    String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
    tmp_str.length(0);
    tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
      (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
    DBUG_PRINT("info",("spider hs readbuf02 size=%zu str=%s",
      (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
  }
#endif
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  (*hs_conn_p)->response_buf_remove();
  if ((*hs_conn_p)->get_error_code())
  {
    DBUG_PRINT("info",("spider hs %d %s",
      (*hs_conn_p)->get_error_code(),
      (*hs_conn_p)->get_error().ptr()));
    (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
  }
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  field_count = (uint) num_fields;
  result->field_count = field_count;
  DBUG_RETURN(result);
}

spider_db_result *spider_db_handlersocket::use_result(
  ha_spider *spider,
  st_spider_db_request_key *request_key,
  int *error_num
) {
  int internal_error;
  spider_db_handlersocket_result *result;
  DBUG_ENTER("spider_db_handlersocket::use_result");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!(result = new spider_db_handlersocket_result(this)))
  {
    *error_num = HA_ERR_OUT_OF_MEM;
    DBUG_RETURN(NULL);
  }
  *error_num = 0;
  result->hs_conn_p = &hs_conn;
  size_t num_fields;
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  if (request_key)
  {
    int tmp_res, tmp_err = (*hs_conn_p)->get_error_code();
    while ((tmp_res = check_request_key(request_key)) == 1)
    {
      DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
        (*hs_conn_p)->get_num_req_bufd()));
      DBUG_PRINT("info",("spider hs num_req_sent=%zu",
        (*hs_conn_p)->get_num_req_sent()));
      DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
        (*hs_conn_p)->get_num_req_rcvd()));
      DBUG_PRINT("info",("spider hs response_end_offset=%zu",
        (*hs_conn_p)->get_response_end_offset()));
      if ((internal_error = (*hs_conn_p)->response_recv(num_fields)))
      {
        if (!tmp_err && internal_error > 0)
        {
          (*hs_conn_p)->clear_error();
        } else {
          (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
#ifndef DBUG_OFF
          if ((*hs_conn_p)->get_response_end_offset() > 0 &&
            (*hs_conn_p)->get_readbuf_begin())
          {
            char tmp_buf[MAX_FIELD_WIDTH];
            String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
            tmp_str.length(0);
            tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
              (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
            DBUG_PRINT("info",("spider hs readbuf01 size=%zu str=%s",
              (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
          }
#endif
          DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
            (*hs_conn_p)->get_num_req_bufd()));
          DBUG_PRINT("info",("spider hs num_req_sent=%zu",
            (*hs_conn_p)->get_num_req_sent()));
          DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
            (*hs_conn_p)->get_num_req_rcvd()));
          DBUG_PRINT("info",("spider hs response_end_offset=%zu",
            (*hs_conn_p)->get_response_end_offset()));
          if (internal_error > 0)
          {
            (*hs_conn_p)->response_buf_remove();
            if ((*hs_conn_p)->get_error_code())
            {
              DBUG_PRINT("info",("spider hs %d %s",
                (*hs_conn_p)->get_error_code(),
                (*hs_conn_p)->get_error().ptr()));
              (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
            }
            DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
              (*hs_conn_p)->get_num_req_bufd()));
            DBUG_PRINT("info",("spider hs num_req_sent=%zu",
              (*hs_conn_p)->get_num_req_sent()));
            DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
              (*hs_conn_p)->get_num_req_rcvd()));
            DBUG_PRINT("info",("spider hs response_end_offset=%zu",
              (*hs_conn_p)->get_response_end_offset()));
            (*hs_conn_p)->clear_error();
          }
          delete result;
          DBUG_RETURN(NULL);
        }
      }
      DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
        (*hs_conn_p)->get_num_req_bufd()));
      DBUG_PRINT("info",("spider hs num_req_sent=%zu",
        (*hs_conn_p)->get_num_req_sent()));
      DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
        (*hs_conn_p)->get_num_req_rcvd()));
      DBUG_PRINT("info",("spider hs response_end_offset=%zu",
        (*hs_conn_p)->get_response_end_offset()));
      (*hs_conn_p)->response_buf_remove();
      DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
        (*hs_conn_p)->get_num_req_bufd()));
      DBUG_PRINT("info",("spider hs num_req_sent=%zu",
        (*hs_conn_p)->get_num_req_sent()));
      DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
        (*hs_conn_p)->get_num_req_rcvd()));
      DBUG_PRINT("info",("spider hs response_end_offset=%zu",
        (*hs_conn_p)->get_response_end_offset()));
    }
    if (tmp_res == -1)
    {
      DBUG_PRINT("info",("spider ER_SPIDER_REQUEST_KEY_NUM"));
      *error_num = ER_SPIDER_REQUEST_KEY_NUM;
      DBUG_RETURN(NULL);
    }
  }
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  if (
    (internal_error = (*hs_conn_p)->response_recv(num_fields))
  ) {
    (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
#ifndef DBUG_OFF
    if ((*hs_conn_p)->get_response_end_offset() > 0 &&
      (*hs_conn_p)->get_readbuf_begin())
    {
      char tmp_buf[MAX_FIELD_WIDTH];
      String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
      tmp_str.length(0);
      tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
        (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
      DBUG_PRINT("info",("spider hs readbuf01 size=%zu str=%s",
        (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
    }
#endif
    DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
      (*hs_conn_p)->get_num_req_bufd()));
    DBUG_PRINT("info",("spider hs num_req_sent=%zu",
      (*hs_conn_p)->get_num_req_sent()));
    DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
      (*hs_conn_p)->get_num_req_rcvd()));
    DBUG_PRINT("info",("spider hs response_end_offset=%zu",
      (*hs_conn_p)->get_response_end_offset()));
    if (internal_error > 0)
    {
      (*hs_conn_p)->response_buf_remove();
      if ((*hs_conn_p)->get_error_code())
      {
        DBUG_PRINT("info",("spider hs %d %s",
          (*hs_conn_p)->get_error_code(),
          (*hs_conn_p)->get_error().ptr()));
        (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
      }
      DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
        (*hs_conn_p)->get_num_req_bufd()));
      DBUG_PRINT("info",("spider hs num_req_sent=%zu",
        (*hs_conn_p)->get_num_req_sent()));
      DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
        (*hs_conn_p)->get_num_req_rcvd()));
      DBUG_PRINT("info",("spider hs response_end_offset=%zu",
        (*hs_conn_p)->get_response_end_offset()));
    }
    delete result;
    DBUG_RETURN(NULL);
  }
#ifndef DBUG_OFF
  if ((*hs_conn_p)->get_response_end_offset() > 0 &&
    (*hs_conn_p)->get_readbuf_begin())
  {
    char tmp_buf[MAX_FIELD_WIDTH];
    String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
    tmp_str.length(0);
    tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
      (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
    DBUG_PRINT("info",("spider hs readbuf02 size=%zu str=%s",
      (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
  }
#endif
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  field_count = (uint) num_fields;
  result->field_count = field_count;
  DBUG_RETURN(result);
}

int spider_db_handlersocket::next_result()
{
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::next_result");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  if ((*hs_conn_p)->stable_point())
    DBUG_RETURN(-1);
  DBUG_RETURN(0);
}

uint spider_db_handlersocket::affected_rows()
{
  int error_num;
  const SPIDER_HS_STRING_REF *hs_row;
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::affected_rows");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  if (
    field_count != 1 ||
    !(hs_row = (*hs_conn_p)->get_next_row()) ||
    !hs_row->begin()
  ) {
    DBUG_RETURN(0);
  }
  DBUG_RETURN((uint) my_strtoll10(hs_row->begin(), (char**) NULL, &error_num));
}

uint spider_db_handlersocket::matched_rows()
{
  DBUG_ENTER("spider_db_handlersocket::matched_rows");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::inserted_info(
  spider_db_handler *handler,
  ha_copy_info *copy_info
) {
  DBUG_ENTER("spider_db_handlersocket::inserted_info");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

ulonglong spider_db_handlersocket::last_insert_id()
{
  DBUG_ENTER("spider_db_handlersocket::last_insert_id");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

int spider_db_handlersocket::set_character_set(
  const char *csname
) {
  DBUG_ENTER("spider_db_handlersocket::set_character_set");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket::select_db(
  const char *dbname
) {
  DBUG_ENTER("spider_db_handlersocket::select_db");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket::consistent_snapshot(
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::consistent_snapshot");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::trx_start_in_bulk_sql()
{
  DBUG_ENTER("spider_db_handlersocket::trx_start_in_bulk_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

int spider_db_handlersocket::start_transaction(
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::start_transaction");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket::commit(
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::commit");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket::rollback(
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::rollback");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::xa_start_in_bulk_sql()
{
  DBUG_ENTER("spider_db_handlersocket::xa_start_in_bulk_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

int spider_db_handlersocket::xa_start(
  XID *xid,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::xa_start");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket::xa_end(
  XID *xid,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::xa_end");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket::xa_prepare(
  XID *xid,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::xa_prepare");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket::xa_commit(
  XID *xid,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::xa_commit");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket::xa_rollback(
  XID *xid,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::xa_rollback");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::set_trx_isolation_in_bulk_sql()
{
  DBUG_ENTER("spider_db_handlersocket::set_trx_isolation_in_bulk_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

int spider_db_handlersocket::set_trx_isolation(
  int trx_isolation,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::set_trx_isolation");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::set_autocommit_in_bulk_sql()
{
  DBUG_ENTER("spider_db_handlersocket::set_autocommit_in_bulk_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

int spider_db_handlersocket::set_autocommit(
  bool autocommit,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::set_autocommit");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::set_sql_log_off_in_bulk_sql()
{
  DBUG_ENTER("spider_db_handlersocket::set_sql_log_off_in_bulk_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

int spider_db_handlersocket::set_sql_log_off(
  bool sql_log_off,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::set_sql_log_off");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::set_wait_timeout_in_bulk_sql()
{
  DBUG_ENTER("spider_db_handlersocket::set_wait_timeout_in_bulk_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

int spider_db_handlersocket::set_wait_timeout(
  int wait_timeout,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::set_wait_timeout");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::set_sql_mode_in_bulk_sql()
{
  DBUG_ENTER("spider_db_handlersocket::set_sql_mode_in_bulk_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

int spider_db_handlersocket::set_sql_mode(
  sql_mode_t sql_mode,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::set_sql_mode");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::set_time_zone_in_bulk_sql()
{
  DBUG_ENTER("spider_db_handlersocket::set_time_zone_in_bulk_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

int spider_db_handlersocket::set_time_zone(
  Time_zone *time_zone,
  int *need_mon
) {
  DBUG_ENTER("spider_db_handlersocket::set_time_zone");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket::show_master_status(
  SPIDER_TRX *trx,
  SPIDER_SHARE *share,
  int all_link_idx,
  int *need_mon,
  TABLE *table,
  spider_string *str,
  int mode,
  SPIDER_DB_RESULT **res1,
  SPIDER_DB_RESULT **res2
) {
  DBUG_ENTER("spider_db_handlersocket::show_master_status");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

int spider_db_handlersocket::append_sql(
  char *sql,
  ulong sql_length,
  st_spider_db_request_key *request_key
) {
  int error_num;
  size_t req_num;
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::append_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  if ((error_num = append_request_key(request_key)))
    DBUG_RETURN(error_num);
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  if (!(req_num = (*hs_conn_p)->request_buf_append(sql, sql + sql_length)))
  {
    DBUG_PRINT("info",("spider hs %d %s",
      (*hs_conn_p)->get_error_code(),
      (*hs_conn_p)->get_error().ptr()));
    (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
    DBUG_RETURN((*hs_conn_p)->get_error_code());
  }
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  while (req_num > 1)
  {
    if ((error_num = append_request_key(request_key)))
      DBUG_RETURN(error_num);
    --req_num;
  }
  DBUG_RETURN(0);
}

int spider_db_handlersocket::append_open_handler(
  uint handler_id,
  const char *db_name,
  const char *table_name,
  const char *index_name,
  const char *sql,
  st_spider_db_request_key *request_key
) {
  int error_num;
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::append_open_handler");
  DBUG_PRINT("info",("spider this=%p", this));
  if ((error_num = append_request_key(request_key)))
    DBUG_RETURN(error_num);
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  (*hs_conn_p)->request_buf_open_index(
    handler_id,
    db_name,
    table_name,
    index_name,
    sql
  );
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  DBUG_RETURN(0);
}

int spider_db_handlersocket::append_select(
  uint handler_id,
  spider_string *sql,
  SPIDER_DB_HS_STRING_REF_BUFFER *keys,
  int limit,
  int skip,
  st_spider_db_request_key *request_key
) {
  int error_num;
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::append_select");
  DBUG_PRINT("info",("spider this=%p", this));
  if ((error_num = append_request_key(request_key)))
    DBUG_RETURN(error_num);
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  (*hs_conn_p)->request_buf_exec_generic(
    handler_id,
    SPIDER_HS_STRING_REF(sql->ptr(), sql->length()),
    keys->ptr(), (size_t) keys->size(),
    limit, skip,
    SPIDER_HS_STRING_REF(),
    NULL, 0);
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  DBUG_RETURN(0);
}

int spider_db_handlersocket::append_insert(
  uint handler_id,
  SPIDER_DB_HS_STRING_REF_BUFFER *upds,
  st_spider_db_request_key *request_key
) {
  int error_num;
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::append_insert");
  DBUG_PRINT("info",("spider this=%p", this));
  if ((error_num = append_request_key(request_key)))
    DBUG_RETURN(error_num);
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  (*hs_conn_p)->request_buf_exec_generic(
    handler_id,
    SPIDER_HS_STRING_REF(SPIDER_SQL_HS_INSERT_STR, SPIDER_SQL_HS_INSERT_LEN),
    upds->ptr(), (size_t) upds->size(),
    0, 0,
    SPIDER_HS_STRING_REF(), NULL, 0);
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  DBUG_RETURN(0);
}

int spider_db_handlersocket::append_update(
  uint handler_id,
  spider_string *sql,
  SPIDER_DB_HS_STRING_REF_BUFFER *keys,
  SPIDER_DB_HS_STRING_REF_BUFFER *upds,
  int limit,
  int skip,
  bool increment,
  bool decrement,
  st_spider_db_request_key *request_key
) {
  int error_num;
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::append_update");
  DBUG_PRINT("info",("spider this=%p", this));
  if ((error_num = append_request_key(request_key)))
    DBUG_RETURN(error_num);
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  (*hs_conn_p)->request_buf_exec_generic(
    handler_id,
    SPIDER_HS_STRING_REF(sql->ptr(), sql->length()),
    keys->ptr(), (size_t) keys->size(),
    limit, skip,
    increment ?
      SPIDER_HS_STRING_REF(SPIDER_SQL_HS_INCREMENT_STR,
        SPIDER_SQL_HS_INCREMENT_LEN) :
      decrement ?
        SPIDER_HS_STRING_REF(SPIDER_SQL_HS_DECREMENT_STR,
          SPIDER_SQL_HS_DECREMENT_LEN) :
        SPIDER_HS_STRING_REF(SPIDER_SQL_HS_UPDATE_STR,
          SPIDER_SQL_HS_UPDATE_LEN),
    upds->ptr(), (size_t) upds->size()
  );
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  DBUG_RETURN(0);
}

int spider_db_handlersocket::append_delete(
  uint handler_id,
  spider_string *sql,
  SPIDER_DB_HS_STRING_REF_BUFFER *keys,
  int limit,
  int skip,
  st_spider_db_request_key *request_key
) {
  int error_num;
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::append_delete");
  DBUG_PRINT("info",("spider this=%p", this));
  if ((error_num = append_request_key(request_key)))
    DBUG_RETURN(error_num);
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  (*hs_conn_p)->request_buf_exec_generic(
    handler_id,
    SPIDER_HS_STRING_REF(sql->ptr(), sql->length()),
    keys->ptr(), (size_t) keys->size(),
    limit, skip,
    SPIDER_HS_STRING_REF(SPIDER_SQL_HS_DELETE_STR, SPIDER_SQL_HS_DELETE_LEN),
    NULL, 0);
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  DBUG_RETURN(0);
}

void spider_db_handlersocket::reset_request_queue()
{
  SPIDER_HS_CONN *hs_conn_p = &hs_conn;
  DBUG_ENTER("spider_db_handlersocket::reset_request_queue");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  (*hs_conn_p)->request_reset();
  DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
    (*hs_conn_p)->get_num_req_bufd()));
  DBUG_PRINT("info",("spider hs num_req_sent=%zu",
    (*hs_conn_p)->get_num_req_sent()));
  DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
    (*hs_conn_p)->get_num_req_rcvd()));
  DBUG_PRINT("info",("spider hs response_end_offset=%zu",
    (*hs_conn_p)->get_response_end_offset()));
  reset_request_key_req();
  DBUG_VOID_RETURN;
}

size_t spider_db_handlersocket::escape_string(
  char *to,
  const char *from,
  size_t from_length
) {
  DBUG_ENTER("spider_db_handlersocket::escape_string");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  memcpy(to, from, from_length);
  DBUG_RETURN(from_length);
}

bool spider_db_handlersocket::have_lock_table_list()
{
  DBUG_ENTER("spider_db_handlersocket::have_lock_table_list");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(FALSE);
}

int spider_db_handlersocket::append_lock_tables(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket::lock_tables");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

int spider_db_handlersocket::append_unlock_tables(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket::append_unlock_tables");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

uint spider_db_handlersocket::get_lock_table_hash_count()
{
  DBUG_ENTER("spider_db_handlersocket::get_lock_table_hash_count");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

void spider_db_handlersocket::reset_lock_table_hash()
{
  DBUG_ENTER("spider_db_handlersocket::reset_lock_table_hash");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_VOID_RETURN;
}

uint spider_db_handlersocket::get_opened_handler_count()
{
  DBUG_ENTER("spider_db_handlersocket::get_opened_handler_count");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(handler_open_array.elements);
}

void spider_db_handlersocket::reset_opened_handler()
{
  ha_spider *tmp_spider;
  int tmp_link_idx;
  SPIDER_LINK_FOR_HASH **tmp_link_for_hash;
  DBUG_ENTER("spider_db_handlersocket::reset_opened_handler");
  DBUG_PRINT("info",("spider this=%p", this));
  while ((tmp_link_for_hash =
    (SPIDER_LINK_FOR_HASH **) pop_dynamic(&handler_open_array)))
  {
    tmp_spider = (*tmp_link_for_hash)->spider;
    tmp_link_idx = (*tmp_link_for_hash)->link_idx;
    tmp_spider->clear_handler_opened(tmp_link_idx, conn->conn_kind);
  }
  DBUG_VOID_RETURN;
}

void spider_db_handlersocket::set_dup_key_idx(
  ha_spider *spider,
  int link_idx
) {
  DBUG_ENTER("spider_db_handlersocket::set_dup_key_idx");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_VOID_RETURN;
}

int spider_db_handlersocket::append_request_key(
  st_spider_db_request_key *request_key
) {
  st_spider_db_request_key *tmp_request_key;
  DBUG_ENTER("spider_db_handlersocket::append_request_key");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info",("spider request_key=%p", request_key));
  if (request_key)
  {
    DBUG_PRINT("info",("spider request_key->spider_thread_id=%llu",
      request_key->spider_thread_id));
    DBUG_PRINT("info",("spider request_key->query_id=%llu",
      request_key->query_id));
    DBUG_PRINT("info",("spider request_key->handler=%p",
      request_key->handler));
    DBUG_PRINT("info",("spider request_key->request_id=%llu",
      request_key->request_id));
    if (request_key_reuse_first)
    {
      tmp_request_key = request_key_reuse_first;
      request_key_reuse_first = request_key_reuse_first->next;
      if (!request_key_reuse_first)
        request_key_reuse_last = NULL;
    } else {
      if (!(tmp_request_key = (st_spider_db_request_key *)
        spider_malloc(spider_current_trx, 1, sizeof(st_spider_db_request_key),
          MYF(MY_WME)))
      )
        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
    }
    *tmp_request_key = *request_key;
    tmp_request_key->next = NULL;
    if (request_key_req_last)
      request_key_req_last->next = tmp_request_key;
    else
      request_key_req_first = tmp_request_key;
    request_key_req_last = tmp_request_key;
  }
  DBUG_RETURN(0);
}

void spider_db_handlersocket::reset_request_key_req()
{
  DBUG_ENTER("spider_db_handlersocket::reset_request_key_req");
  DBUG_PRINT("info",("spider this=%p", this));
  if (request_key_req_first)
  {
    if (request_key_reuse_last)
      request_key_reuse_last->next = request_key_req_first;
    else
      request_key_reuse_first = request_key_req_first;
    request_key_reuse_last = request_key_req_last;
    request_key_req_first = NULL;
    request_key_req_last = NULL;
  }
  DBUG_VOID_RETURN;
}

void spider_db_handlersocket::reset_request_key_snd()
{
  DBUG_ENTER("spider_db_handlersocket::reset_request_key_snd");
  DBUG_PRINT("info",("spider this=%p", this));
  if (request_key_snd_first)
  {
    if (request_key_reuse_last)
      request_key_reuse_last->next = request_key_snd_first;
    else
      request_key_reuse_first = request_key_snd_first;
    request_key_reuse_last = request_key_snd_last;
    request_key_snd_first = NULL;
    request_key_snd_last = NULL;
  }
  DBUG_VOID_RETURN;
}

void spider_db_handlersocket::move_request_key_to_snd()
{
  DBUG_ENTER("spider_db_handlersocket::move_request_key_to_snd");
  DBUG_PRINT("info",("spider this=%p", this));
  if (request_key_req_first)
  {
    if (request_key_snd_last)
      request_key_snd_last->next = request_key_req_first;
    else
      request_key_snd_first = request_key_req_first;
    request_key_snd_last = request_key_req_last;
    request_key_req_first = NULL;
    request_key_req_last = NULL;
  }
  DBUG_VOID_RETURN;
}

int spider_db_handlersocket::check_request_key(
  st_spider_db_request_key *request_key
) {
  st_spider_db_request_key *tmp_request_key;
  DBUG_ENTER("spider_db_handlersocket::check_request_key");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info",("spider request_key=%p", request_key));
  DBUG_PRINT("info",("spider request_key_snd_first=%p",
    request_key_snd_first));
  if (!request_key_snd_first)
  {
    DBUG_PRINT("info",("spider -1"));
    DBUG_RETURN(-1);
  }
  tmp_request_key = request_key_snd_first;
  request_key_snd_first = request_key_snd_first->next;
  if (!request_key_snd_first)
    request_key_snd_last = NULL;
  tmp_request_key->next = NULL;
  if (request_key_reuse_last)
    request_key_reuse_last->next = tmp_request_key;
  else
    request_key_reuse_first = tmp_request_key;
  request_key_reuse_last = tmp_request_key;

  DBUG_PRINT("info",("spider tmp_request_key->spider_thread_id=%llu",
    tmp_request_key->spider_thread_id));
  DBUG_PRINT("info",("spider request_key->spider_thread_id=%llu",
    request_key->spider_thread_id));
  DBUG_PRINT("info",("spider tmp_request_key->query_id=%llu",
    tmp_request_key->query_id));
  DBUG_PRINT("info",("spider request_key->query_id=%llu",
    request_key->query_id));
  DBUG_PRINT("info",("spider tmp_request_key->handler=%p",
    tmp_request_key->handler));
  DBUG_PRINT("info",("spider request_key->handler=%p",
    request_key->handler));
  DBUG_PRINT("info",("spider tmp_request_key->request_id=%llu",
    tmp_request_key->request_id));
  DBUG_PRINT("info",("spider request_key->request_id=%llu",
    request_key->request_id));
  if (
    tmp_request_key->spider_thread_id != request_key->spider_thread_id ||
    tmp_request_key->query_id != request_key->query_id ||
    tmp_request_key->handler != request_key->handler ||
    tmp_request_key->request_id != request_key->request_id
  ) {
    DBUG_PRINT("info",("spider 1"));
    DBUG_RETURN(1);
  }
  DBUG_PRINT("info",("spider 0"));
  DBUG_RETURN(0);
}

bool spider_db_handlersocket::cmp_request_key_to_snd(
  st_spider_db_request_key *request_key
) {
  DBUG_ENTER("spider_db_handlersocket::cmp_request_key_to_snd");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info",("spider request_key=%p", request_key));
  if (
    !request_key
  ) {
    DBUG_PRINT("info",("spider TRUE"));
    DBUG_RETURN(TRUE);
  }
  DBUG_PRINT("info",("spider request_key_snd_first=%p",
    request_key_snd_first));
  if (
    !request_key_snd_first
  ) {
    DBUG_PRINT("info",("spider FALSE"));
    DBUG_RETURN(FALSE);
  }
  DBUG_PRINT("info",("spider request_key_snd_first->spider_thread_id=%llu",
    request_key_snd_first->spider_thread_id));
  DBUG_PRINT("info",("spider request_key->spider_thread_id=%llu",
    request_key->spider_thread_id));
  DBUG_PRINT("info",("spider request_key_snd_first->query_id=%llu",
    request_key_snd_first->query_id));
  DBUG_PRINT("info",("spider request_key->query_id=%llu",
    request_key->query_id));
  DBUG_PRINT("info",("spider request_key_snd_first->handler=%p",
    request_key_snd_first->handler));
  DBUG_PRINT("info",("spider request_key->handler=%p",
    request_key->handler));
  DBUG_PRINT("info",("spider request_key_snd_first->request_id=%llu",
    request_key_snd_first->request_id));
  DBUG_PRINT("info",("spider request_key->request_id=%llu",
    request_key->request_id));
  if (
    request_key_snd_first->spider_thread_id != request_key->spider_thread_id ||
    request_key_snd_first->query_id != request_key->query_id ||
    request_key_snd_first->handler != request_key->handler ||
    request_key_snd_first->request_id != request_key->request_id
  ) {
    DBUG_PRINT("info",("spider FALSE"));
    DBUG_RETURN(FALSE);
  }
  DBUG_PRINT("info",("spider TRUE"));
  DBUG_RETURN(TRUE);
}

spider_db_handlersocket_util::spider_db_handlersocket_util() : spider_db_util()
{
  DBUG_ENTER("spider_db_handlersocket_util::spider_db_handlersocket_util");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

spider_db_handlersocket_util::~spider_db_handlersocket_util()
{
  DBUG_ENTER("spider_db_handlersocket_util::~spider_db_handlersocket_util");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_VOID_RETURN;
}

int spider_db_handlersocket_util::append_name(
  spider_string *str,
  const char *name,
  uint name_length
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_name");
  str->q_append(name, name_length);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_name_with_charset(
  spider_string *str,
  const char *name,
  uint name_length,
  CHARSET_INFO *name_charset
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_name_with_charset");
  if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length * 2))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
  str->append(name, name_length, name_charset);
  if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_escaped_name(
  spider_string *str,
  const char *name,
  uint name_length
) {
  int error_num;
  DBUG_ENTER("spider_db_handlersocket_util::append_name");
  if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length * 2))
  {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
  str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
  if ((error_num = spider_db_append_name_with_quote_str_internal(
    str, name, name_length, dbton_id)))
  {
    DBUG_RETURN(error_num);
  }
  if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
  {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
  str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_escaped_name_with_charset(
  spider_string *str,
  const char *name,
  uint name_length,
  CHARSET_INFO *name_charset
) {
  int error_num;
  DBUG_ENTER("spider_db_handlersocket_util::append_name_with_charset");
  if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length * 2))
  {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
  str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
  if ((error_num = spider_db_append_name_with_quote_str_internal(
    str, name, name_length, name_charset, dbton_id)))
  {
    DBUG_RETURN(error_num);
  }
  if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
  {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
  str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
  DBUG_RETURN(0);
}

bool spider_db_handlersocket_util::is_name_quote(
  const char head_code
) {
  DBUG_ENTER("spider_db_handlersocket_util::is_name_quote");
  DBUG_RETURN(head_code == *name_quote_str);
}

int spider_db_handlersocket_util::append_escaped_name_quote(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_escaped_name_quote");
  if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
  str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_column_value(
  ha_spider *spider,
  spider_string *str,
  Field *field,
  const uchar *new_ptr,
  CHARSET_INFO *access_charset
) {
  char buf[MAX_FIELD_WIDTH];
  spider_string tmp_str(buf, MAX_FIELD_WIDTH, &my_charset_bin);
  String *ptr;
  uint length;
  DBUG_ENTER("spider_db_handlersocket_util::append_column_value");
  tmp_str.init_calc_mem(180);

  if (new_ptr)
  {
    if (
      field->type() == MYSQL_TYPE_BLOB ||
      field->real_type() == MYSQL_TYPE_VARCHAR
    ) {
      length = uint2korr(new_ptr);
      tmp_str.set_quick((char *) new_ptr + HA_KEY_BLOB_LENGTH, length,
        &my_charset_bin);
      ptr = tmp_str.get_str();
    } else if (field->type() == MYSQL_TYPE_GEOMETRY)
    {
/*
      uint mlength = SIZEOF_STORED_DOUBLE, lcnt;
      uchar *dest = (uchar *) buf;
      const uchar *source;
      for (lcnt = 0; lcnt < 4; lcnt++)
      {
        mlength = SIZEOF_STORED_DOUBLE;
        source = new_ptr + mlength + SIZEOF_STORED_DOUBLE * lcnt;
        while (mlength--)
          *dest++ = *--source;
      }
      tmp_str.length(SIZEOF_STORED_DOUBLE * lcnt);
*/
      double xmin, xmax, ymin, ymax;
/*
      float8store(buf,xmin);
      float8store(buf+8,xmax);
      float8store(buf+16,ymin);
      float8store(buf+24,ymax);
      memcpy(&xmin,new_ptr,sizeof(xmin));
      memcpy(&xmax,new_ptr + 8,sizeof(xmax));
      memcpy(&ymin,new_ptr + 16,sizeof(ymin));
      memcpy(&ymax,new_ptr + 24,sizeof(ymax));
      float8get(xmin, buf);
      float8get(xmax, buf + 8);
      float8get(ymin, buf + 16);
      float8get(ymax, buf + 24);
      DBUG_PRINT("info", ("spider geo is %f %f %f %f",
        xmin, xmax, ymin, ymax));
      DBUG_PRINT("info", ("spider geo is %.14g %.14g %.14g %.14g",
        xmin, xmax, ymin, ymax));
*/
      float8get(xmin, new_ptr);
      float8get(xmax, new_ptr + 8);
      float8get(ymin, new_ptr + 16);
      float8get(ymax, new_ptr + 24);
      DBUG_PRINT("info", ("spider geo is %f %f %f %f",
        xmin, xmax, ymin, ymax));
/*
      float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 4);
      float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 5);
      float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 6);
      float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 7);
      DBUG_PRINT("info", ("spider geo is %f %f %f %f",
        xmin, xmax, ymin, ymax));
      float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 8);
      float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 9);
      float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 10);
      float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 11);
      DBUG_PRINT("info", ("spider geo is %f %f %f %f",
        xmin, xmax, ymin, ymax));
      float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 12);
      float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 13);
      float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 14);
      float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 15);
      DBUG_PRINT("info", ("spider geo is %f %f %f %f",
        xmin, xmax, ymin, ymax));
*/
/*
      tmp_str.set_quick((char *) new_ptr, SIZEOF_STORED_DOUBLE * 4,
        &my_charset_bin);
*/
      tmp_str.length(0);
      tmp_str.q_append((char *) SPIDER_SQL_LINESTRING_HEAD_STR,
        SPIDER_SQL_LINESTRING_HEAD_LEN);
      tmp_str.q_append((char *) new_ptr, SIZEOF_STORED_DOUBLE);
      tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE * 2,
        SIZEOF_STORED_DOUBLE);
      tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE,
        SIZEOF_STORED_DOUBLE);
      tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE * 3,
        SIZEOF_STORED_DOUBLE);
      ptr = tmp_str.get_str();
    } else {
      ptr = field->val_str(tmp_str.get_str(), new_ptr);
      tmp_str.mem_calc();
    }
  } else {
    ptr = field->val_str(tmp_str.get_str());
    tmp_str.mem_calc();
  }
  DBUG_PRINT("info", ("spider field->type() is %d", field->type()));
  DBUG_PRINT("info", ("spider ptr->length() is %d", ptr->length()));
/*
  if (
    field->type() == MYSQL_TYPE_BIT ||
    (field->type() >= MYSQL_TYPE_TINY_BLOB &&
      field->type() <= MYSQL_TYPE_BLOB)
  ) {
    uchar *hex_ptr = (uchar *) ptr->ptr(), *end_ptr;
    char *str_ptr;
    DBUG_PRINT("info", ("spider HEX"));
    if (str->reserve(SPIDER_SQL_HEX_LEN + ptr->length() * 2))
      DBUG_RETURN(HA_ERR_OUT_OF_MEM);
    str->q_append(SPIDER_SQL_HEX_STR, SPIDER_SQL_HEX_LEN);
    str_ptr = (char *) str->ptr() + str->length();
    for (end_ptr = hex_ptr + ptr->length(); hex_ptr < end_ptr; hex_ptr++)
    {
      *str_ptr++ = spider_dig_upper[(*hex_ptr) >> 4];
      *str_ptr++ = spider_dig_upper[(*hex_ptr) & 0x0F];
    }
    str->length(str->length() + ptr->length() * 2);
  } else 
*/
  spider_handlersocket_handler *hs_handler = (spider_handlersocket_handler *)
    spider->dbton_handler[spider_dbton_handlersocket.dbton_id];
  spider_string *hs_str;
  if (!(hs_str = hs_handler->hs_strs.add(
    &hs_handler->hs_strs_pos, ptr->ptr(), ptr->length())))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  SPIDER_HS_STRING_REF ref =
    SPIDER_HS_STRING_REF(hs_str->ptr(), hs_str->length());
  if (hs_handler->hs_adding_keys)
  {
    DBUG_PRINT("info", ("spider add to key:%s", hs_str->c_ptr_safe()));
    hs_handler->hs_keys.push_back(ref);
  } else {
    DBUG_PRINT("info", ("spider add to upd:%s", hs_str->c_ptr_safe()));
    hs_handler->hs_upds.push_back(ref);
  }
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_trx_isolation(
  spider_string *str,
  int trx_isolation
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_trx_isolation");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_autocommit(
  spider_string *str,
  bool autocommit
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_autocommit");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_sql_log_off(
  spider_string *str,
  bool sql_log_off
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_sql_log_off");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_wait_timeout(
  spider_string *str,
  int wait_timeout
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_wait_timeout");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_sql_mode(
  spider_string *str,
  sql_mode_t sql_mode
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_sql_mode");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_time_zone(
  spider_string *str,
  Time_zone *time_zone
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_time_zone");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_start_transaction(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_start_transaction");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_xa_start(
  spider_string *str,
  XID *xid
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_xa_start");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_lock_table_head(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_lock_table_head");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_lock_table_body(
  spider_string *str,
  const char *db_name,
  uint db_name_length,
  CHARSET_INFO *db_name_charset,
  const char *table_name,
  uint table_name_length,
  CHARSET_INFO *table_name_charset,
  int lock_type
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_lock_table_body");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_lock_table_tail(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_lock_table_tail");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_unlock_table(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_unlock_table");
  DBUG_PRINT("info",("spider this=%p", this));
  /* nothing to do */
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::open_item_func(
  Item_func *item_func,
  ha_spider *spider,
  spider_string *str,
  const char *alias,
  uint alias_length,
  bool use_fields,
  spider_fields *fields
) {
  uint dbton_id = spider_dbton_handlersocket.dbton_id;
  int error_num;
  Item *item, **item_list = item_func->arguments();
  uint roop_count, item_count = item_func->argument_count(), start_item = 0;
  const char *func_name = SPIDER_SQL_NULL_CHAR_STR,
    *separator_str = SPIDER_SQL_NULL_CHAR_STR,
    *last_str = SPIDER_SQL_NULL_CHAR_STR;
  int func_name_length = SPIDER_SQL_NULL_CHAR_LEN,
    separator_str_length = SPIDER_SQL_NULL_CHAR_LEN,
    last_str_length = SPIDER_SQL_NULL_CHAR_LEN;
  int use_pushdown_udf;
  bool merge_func = FALSE;
  DBUG_ENTER("spider_db_handlersocket_util::open_item_func");
  if (str)
  {
    if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
      DBUG_RETURN(HA_ERR_OUT_OF_MEM);
    str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
  }
  DBUG_PRINT("info",("spider functype = %d", item_func->functype()));
  switch (item_func->functype())
  {
    case Item_func::ISNULL_FUNC:
      last_str = SPIDER_SQL_IS_NULL_STR;
      last_str_length = SPIDER_SQL_IS_NULL_LEN;
      break;
    case Item_func::ISNOTNULL_FUNC:
      last_str = SPIDER_SQL_IS_NOT_NULL_STR;
      last_str_length = SPIDER_SQL_IS_NOT_NULL_LEN;
      break;
    case Item_func::UNKNOWN_FUNC:
      func_name = (char*) item_func->func_name();
      func_name_length = strlen(func_name);
      DBUG_PRINT("info",("spider func_name = %s", func_name));
      DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
      if (func_name_length == 1 &&
        (
          !strncasecmp("+", func_name, func_name_length) ||
          !strncasecmp("-", func_name, func_name_length) ||
          !strncasecmp("*", func_name, func_name_length) ||
          !strncasecmp("/", func_name, func_name_length) ||
          !strncasecmp("%", func_name, func_name_length) ||
          !strncasecmp("&", func_name, func_name_length) ||
          !strncasecmp("|", func_name, func_name_length) ||
          !strncasecmp("^", func_name, func_name_length)
        )
      ) {
        /* no action */
        break;
      } else if (func_name_length == 2 &&
        (
          !strncasecmp("<<", func_name, func_name_length) ||
          !strncasecmp(">>", func_name, func_name_length)
        )
      ) {
        /* no action */
        break;
      } else if (func_name_length == 3 &&
        !strncasecmp("div", func_name, func_name_length)
      ) {
        /* no action */
        break;
      } else if (func_name_length == 4)
      {
        if (
          !strncasecmp("rand", func_name, func_name_length) &&
#ifdef SPIDER_Item_args_arg_count_IS_PROTECTED
          !item_func->argument_count()
#else
          !item_func->arg_count
#endif
        ) {
          if (str)
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
          DBUG_RETURN(spider_db_open_item_int(item_func, NULL, spider, str,
            alias, alias_length, dbton_id, use_fields, fields));
        } else if (
          !strncasecmp("case", func_name, func_name_length)
        ) {
#ifdef ITEM_FUNC_CASE_PARAMS_ARE_PUBLIC
          Item_func_case *item_func_case = (Item_func_case *) item_func;
          if (str)
          {
            if (str->reserve(SPIDER_SQL_CASE_LEN))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            str->q_append(SPIDER_SQL_CASE_STR, SPIDER_SQL_CASE_LEN);
          }
          if (item_func_case->first_expr_num != -1)
          {
            if ((error_num = spider_db_print_item_type(
              item_list[item_func_case->first_expr_num], NULL, spider, str,
              alias, alias_length, dbton_id, use_fields, fields)))
              DBUG_RETURN(error_num);
          }
          for (roop_count = 0; roop_count < item_func_case->ncases;
            roop_count += 2)
          {
            if (str)
            {
              if (str->reserve(SPIDER_SQL_WHEN_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_WHEN_STR, SPIDER_SQL_WHEN_LEN);
            }
            if ((error_num = spider_db_print_item_type(
              item_list[roop_count], NULL, spider, str,
              alias, alias_length, dbton_id, use_fields, fields)))
              DBUG_RETURN(error_num);
            if (str)
            {
              if (str->reserve(SPIDER_SQL_THEN_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_THEN_STR, SPIDER_SQL_THEN_LEN);
            }
            if ((error_num = spider_db_print_item_type(
              item_list[roop_count + 1], NULL, spider, str,
              alias, alias_length, dbton_id, use_fields, fields)))
              DBUG_RETURN(error_num);
          }
          if (item_func_case->else_expr_num != -1)
          {
            if (str)
            {
              if (str->reserve(SPIDER_SQL_ELSE_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_ELSE_STR, SPIDER_SQL_ELSE_LEN);
            }
            if ((error_num = spider_db_print_item_type(
              item_list[item_func_case->else_expr_num], NULL, spider, str,
              alias, alias_length, dbton_id, use_fields, fields)))
              DBUG_RETURN(error_num);
          }
          if (str)
          {
            if (str->reserve(SPIDER_SQL_END_LEN + SPIDER_SQL_CLOSE_PAREN_LEN))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            str->q_append(SPIDER_SQL_END_STR, SPIDER_SQL_END_LEN);
            str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
              SPIDER_SQL_CLOSE_PAREN_LEN);
          }
          DBUG_RETURN(0);
#else
          DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
#endif
        }
      } else if (func_name_length == 6 &&
        !strncasecmp("istrue", func_name, func_name_length)
      ) {
        last_str = SPIDER_SQL_IS_TRUE_STR;
        last_str_length = SPIDER_SQL_IS_TRUE_LEN;
        break;
      } else if (func_name_length == 7)
      {
        if (!strncasecmp("isfalse", func_name, func_name_length))
        {
          last_str = SPIDER_SQL_IS_FALSE_STR;
          last_str_length = SPIDER_SQL_IS_FALSE_LEN;
          break;
        } else if (
          !strncasecmp("sysdate", func_name, func_name_length) ||
          !strncasecmp("curdate", func_name, func_name_length) ||
          !strncasecmp("curtime", func_name, func_name_length)
        ) {
          if (str)
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
          DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
            alias, alias_length, dbton_id, use_fields, fields));
        } else if (
          !strncasecmp("convert", func_name, func_name_length)
        ) {
          if (str)
          {
            if (str->reserve(func_name_length * 2 + SPIDER_SQL_OPEN_PAREN_LEN))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            str->q_append(func_name, func_name_length);
            str->q_append(SPIDER_SQL_OPEN_PAREN_STR,
              SPIDER_SQL_OPEN_PAREN_LEN);
            last_str = SPIDER_SQL_CLOSE_PAREN_STR;
            last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
          }
          break;
        }
      } else if (func_name_length == 8 &&
        (
          !strncasecmp("utc_date", func_name, func_name_length) ||
          !strncasecmp("utc_time", func_name, func_name_length)
        )
      ) {
        if (str)
          str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
        DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
          alias, alias_length, dbton_id, use_fields, fields));
      } else if (func_name_length == 9 &&
        !strncasecmp("isnottrue", func_name, func_name_length)
      ) {
        last_str = SPIDER_SQL_IS_NOT_TRUE_STR;
        last_str_length = SPIDER_SQL_IS_NOT_TRUE_LEN;
        break;
      } else if (func_name_length == 10)
      {
        if (!strncasecmp("isnotfalse", func_name, func_name_length))
        {
          last_str = SPIDER_SQL_IS_NOT_FALSE_STR;
          last_str_length = SPIDER_SQL_IS_NOT_FALSE_LEN;
          break;
        } else if (!strncasecmp("column_get", func_name, func_name_length))
        {
          if (str)
          {
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
            if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            str->q_append(func_name, func_name_length);
            str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
          }
          func_name = SPIDER_SQL_COMMA_STR;
          func_name_length = SPIDER_SQL_COMMA_LEN;
          separator_str = SPIDER_SQL_COMMA_STR;
          separator_str_length = SPIDER_SQL_COMMA_LEN;
          break;
        }
      } else if (func_name_length == 12)
      {
        if (!strncasecmp("cast_as_date", func_name, func_name_length))
        {
          item = item_list[0];
          if (item->type() == Item::FUNC_ITEM)
          {
            DBUG_PRINT("info",("spider child is FUNC_ITEM"));
            Item_func *ifunc = (Item_func *) item;
            if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
            {
              const char *child_func_name;
              int child_func_name_length;
              DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
              child_func_name = (char*) ifunc->func_name();
              child_func_name_length = strlen(child_func_name);
              DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
              if (
                child_func_name_length == 10 &&
                !strncasecmp("column_get", child_func_name, child_func_name_length)
              ) {
                DBUG_PRINT("info",("spider this is merge func"));
                merge_func = TRUE;
              }
            }
          }

          if (str)
          {
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
            if (!merge_func)
            {
              if (str->reserve(SPIDER_SQL_CAST_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
            }
          }
          last_str = SPIDER_SQL_AS_DATE_STR;
          last_str_length = SPIDER_SQL_AS_DATE_LEN;
          break;
        } else if (!strncasecmp("cast_as_time", func_name, func_name_length))
        {
          item = item_list[0];
          if (item->type() == Item::FUNC_ITEM)
          {
            DBUG_PRINT("info",("spider child is FUNC_ITEM"));
            Item_func *ifunc = (Item_func *) item;
            if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
            {
              const char *child_func_name;
              int child_func_name_length;
              DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
              child_func_name = (char*) ifunc->func_name();
              child_func_name_length = strlen(child_func_name);
              DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
              if (
                child_func_name_length == 10 &&
                !strncasecmp("column_get", child_func_name, child_func_name_length)
              ) {
                DBUG_PRINT("info",("spider this is merge func"));
                merge_func = TRUE;
              }
            }
          }

          if (str)
          {
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
            if (!merge_func)
            {
              if (str->reserve(SPIDER_SQL_CAST_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
            }
          }
          last_str = SPIDER_SQL_AS_TIME_STR;
          last_str_length = SPIDER_SQL_AS_TIME_LEN;
          break;
        }
      } else if (func_name_length == 13)
      {
        if (!strncasecmp("utc_timestamp", func_name, func_name_length))
        {
          if (str)
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
          DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
            alias, alias_length, dbton_id, use_fields, fields));
        } else if (!strncasecmp("timestampdiff", func_name, func_name_length))
        {
#ifdef ITEM_FUNC_TIMESTAMPDIFF_ARE_PUBLIC
          Item_func_timestamp_diff *item_func_timestamp_diff =
            (Item_func_timestamp_diff *) item_func;
          if (str)
          {
            const char *interval_str;
            uint interval_len;
            switch (item_func_timestamp_diff->int_type)
            {
              case INTERVAL_YEAR:
                interval_str = SPIDER_SQL_YEAR_STR;
                interval_len = SPIDER_SQL_YEAR_LEN;
                break;
              case INTERVAL_QUARTER:
                interval_str = SPIDER_SQL_QUARTER_STR;
                interval_len = SPIDER_SQL_QUARTER_LEN;
                break;
              case INTERVAL_MONTH:
                interval_str = SPIDER_SQL_MONTH_STR;
                interval_len = SPIDER_SQL_MONTH_LEN;
                break;
              case INTERVAL_WEEK:
                interval_str = SPIDER_SQL_WEEK_STR;
                interval_len = SPIDER_SQL_WEEK_LEN;
                break;
              case INTERVAL_DAY:
                interval_str = SPIDER_SQL_DAY_STR;
                interval_len = SPIDER_SQL_DAY_LEN;
                break;
              case INTERVAL_HOUR:
                interval_str = SPIDER_SQL_HOUR_STR;
                interval_len = SPIDER_SQL_HOUR_LEN;
                break;
              case INTERVAL_MINUTE:
                interval_str = SPIDER_SQL_MINUTE_STR;
                interval_len = SPIDER_SQL_MINUTE_LEN;
                break;
              case INTERVAL_SECOND:
                interval_str = SPIDER_SQL_SECOND_STR;
                interval_len = SPIDER_SQL_SECOND_LEN;
                break;
              case INTERVAL_MICROSECOND:
                interval_str = SPIDER_SQL_MICROSECOND_STR;
                interval_len = SPIDER_SQL_MICROSECOND_LEN;
                break;
              default:
                interval_str = "";
                interval_len = 0;
                break;
            }
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
            if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN +
              interval_len + SPIDER_SQL_COMMA_LEN))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            str->q_append(func_name, func_name_length);
            str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
            str->q_append(interval_str, interval_len);
            str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
          }
          if ((error_num = spider_db_print_item_type(item_list[0], NULL, spider,
            str, alias, alias_length, dbton_id, use_fields, fields)))
            DBUG_RETURN(error_num);
          if (str)
          {
            if (str->reserve(SPIDER_SQL_COMMA_LEN))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
          }
          if ((error_num = spider_db_print_item_type(item_list[1], NULL, spider,
            str, alias, alias_length, dbton_id, use_fields, fields)))
            DBUG_RETURN(error_num);
          if (str)
          {
            if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
              SPIDER_SQL_CLOSE_PAREN_LEN);
          }
          DBUG_RETURN(0);
#else
          DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
#endif
        }
      } else if (func_name_length == 14)
      {
        if (!strncasecmp("cast_as_binary", func_name, func_name_length))
        {
          item = item_list[0];
          if (item->type() == Item::FUNC_ITEM)
          {
            DBUG_PRINT("info",("spider child is FUNC_ITEM"));
            Item_func *ifunc = (Item_func *) item;
            if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
            {
              const char *child_func_name;
              int child_func_name_length;
              DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
              child_func_name = (char*) ifunc->func_name();
              child_func_name_length = strlen(child_func_name);
              DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
              if (
                child_func_name_length == 10 &&
                !strncasecmp("column_get", child_func_name, child_func_name_length)
              ) {
                DBUG_PRINT("info",("spider this is merge func"));
                merge_func = TRUE;
              }
            }
          }

          if (str)
          {
            char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;
            spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
            tmp_str.init_calc_mem(123);
            tmp_str.length(0);
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
            if (!merge_func)
            {
              if (str->reserve(SPIDER_SQL_CAST_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
            }
#if MYSQL_VERSION_ID < 50500
            item_func->print(tmp_str.get_str(), QT_IS);
#else
            item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET);
#endif
            tmp_str.mem_calc();
            if (tmp_str.reserve(1))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            tmp_ptr = tmp_str.c_ptr_quick();
            DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));
            while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_BINARY_STR)))
              tmp_ptr = tmp_ptr2 + 1;
            last_str = tmp_ptr - 1;
            last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;
          }
          break;
        } else if (!strncasecmp("cast_as_signed", func_name, func_name_length))
        {
          item = item_list[0];
          if (item->type() == Item::FUNC_ITEM)
          {
            DBUG_PRINT("info",("spider child is FUNC_ITEM"));
            Item_func *ifunc = (Item_func *) item;
            if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
            {
              const char *child_func_name;
              int child_func_name_length;
              DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
              child_func_name = (char*) ifunc->func_name();
              child_func_name_length = strlen(child_func_name);
              DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
              if (
                child_func_name_length == 10 &&
                !strncasecmp("column_get", child_func_name, child_func_name_length)
              ) {
                DBUG_PRINT("info",("spider this is merge func"));
                merge_func = TRUE;
              }
            }
          }

          if (str)
          {
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
            if (!merge_func)
            {
              if (str->reserve(SPIDER_SQL_CAST_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
            }
          }
          last_str = SPIDER_SQL_AS_SIGNED_STR;
          last_str_length = SPIDER_SQL_AS_SIGNED_LEN;
          break;
        }
      } else if (func_name_length == 16)
      {
        if (!strncasecmp("cast_as_unsigned", func_name, func_name_length))
        {
          item = item_list[0];
          if (item->type() == Item::FUNC_ITEM)
          {
            DBUG_PRINT("info",("spider child is FUNC_ITEM"));
            Item_func *ifunc = (Item_func *) item;
            if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
            {
              const char *child_func_name;
              int child_func_name_length;
              DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
              child_func_name = (char*) ifunc->func_name();
              child_func_name_length = strlen(child_func_name);
              DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
              if (
                child_func_name_length == 10 &&
                !strncasecmp("column_get", child_func_name, child_func_name_length)
              ) {
                DBUG_PRINT("info",("spider this is merge func"));
                merge_func = TRUE;
              }
            }
          }

          if (str)
          {
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
            if (!merge_func)
            {
              if (str->reserve(SPIDER_SQL_CAST_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
            }
          }
          last_str = SPIDER_SQL_AS_UNSIGNED_STR;
          last_str_length = SPIDER_SQL_AS_UNSIGNED_LEN;
          break;
        } else if (!strncasecmp("decimal_typecast", func_name,
          func_name_length))
        {
          item = item_list[0];
          if (item->type() == Item::FUNC_ITEM)
          {
            DBUG_PRINT("info",("spider child is FUNC_ITEM"));
            Item_func *ifunc = (Item_func *) item;
            if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
            {
              const char *child_func_name;
              int child_func_name_length;
              DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
              child_func_name = (char*) ifunc->func_name();
              child_func_name_length = strlen(child_func_name);
              DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
              if (
                child_func_name_length == 10 &&
                !strncasecmp("column_get", child_func_name, child_func_name_length)
              ) {
                DBUG_PRINT("info",("spider this is merge func"));
                merge_func = TRUE;
              }
            }
          }

          if (str)
          {
            char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;
            spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
            tmp_str.init_calc_mem(124);
            tmp_str.length(0);
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
            if (!merge_func)
            {
              if (str->reserve(SPIDER_SQL_CAST_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
            }
#if MYSQL_VERSION_ID < 50500
            item_func->print(tmp_str.get_str(), QT_IS);
#else
            item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET);
#endif
            tmp_str.mem_calc();
            if (tmp_str.reserve(1))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            tmp_ptr = tmp_str.c_ptr_quick();
            DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));
            while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_DECIMAL_STR)))
              tmp_ptr = tmp_ptr2 + 1;
            last_str = tmp_ptr - 1;
            last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;
          }
          break;
        } else if (!strncasecmp("cast_as_datetime", func_name,
          func_name_length))
        {
          item = item_list[0];
          if (item->type() == Item::FUNC_ITEM)
          {
            DBUG_PRINT("info",("spider child is FUNC_ITEM"));
            Item_func *ifunc = (Item_func *) item;
            if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
            {
              const char *child_func_name;
              int child_func_name_length;
              DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
              child_func_name = (char*) ifunc->func_name();
              child_func_name_length = strlen(child_func_name);
              DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
              if (
                child_func_name_length == 10 &&
                !strncasecmp("column_get", child_func_name, child_func_name_length)
              ) {
                DBUG_PRINT("info",("spider this is merge func"));
                merge_func = TRUE;
              }
            }
          }

          if (str)
          {
            str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
            if (!merge_func)
            {
              if (str->reserve(SPIDER_SQL_CAST_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
            }
          }
          last_str = SPIDER_SQL_AS_DATETIME_STR;
          last_str_length = SPIDER_SQL_AS_DATETIME_LEN;
          break;
        }
      } else if (func_name_length == 17)
      {
        if (!strncasecmp("date_add_interval", func_name, func_name_length))
        {
          Item_date_add_interval *item_date_add_interval =
            (Item_date_add_interval *) item_func;
          func_name = spider_db_timefunc_interval_str[
            item_date_add_interval->int_type];
          func_name_length = strlen(func_name);
          if ((error_num = spider_db_print_item_type(item_list[0], NULL, spider,
            str, alias, alias_length, dbton_id, use_fields, fields)))
            DBUG_RETURN(error_num);
          if (str)
          {
            if (item_date_add_interval->date_sub_interval)
            {
              if (str->reserve(SPIDER_SQL_NEGINTERVAL_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_NEGINTERVAL_STR,
                SPIDER_SQL_NEGINTERVAL_LEN);
            } else {
              if (str->reserve(SPIDER_SQL_INTERVAL_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_INTERVAL_STR, SPIDER_SQL_INTERVAL_LEN);
            }
          }
          if ((error_num = spider_db_print_item_type(item_list[1], NULL, spider,
            str, alias, alias_length, dbton_id, use_fields, fields)))
            DBUG_RETURN(error_num);
          if (str)
          {
            if (str->reserve(func_name_length + SPIDER_SQL_CLOSE_PAREN_LEN))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            str->q_append(func_name, func_name_length);
            str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
              SPIDER_SQL_CLOSE_PAREN_LEN);
          }
          DBUG_RETURN(0);
        }
      }
      if (str)
      {
        if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
        str->q_append(func_name, func_name_length);
        str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
      }
      func_name = SPIDER_SQL_COMMA_STR;
      func_name_length = SPIDER_SQL_COMMA_LEN;
      separator_str = SPIDER_SQL_COMMA_STR;
      separator_str_length = SPIDER_SQL_COMMA_LEN;
      last_str = SPIDER_SQL_CLOSE_PAREN_STR;
      last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
      break;
    case Item_func::NOW_FUNC:
      if (str)
        str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
      DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
        alias, alias_length, dbton_id, use_fields, fields));
    case Item_func::CHAR_TYPECAST_FUNC:
      DBUG_PRINT("info",("spider CHAR_TYPECAST_FUNC"));
      {
        item = item_list[0];
        if (item->type() == Item::FUNC_ITEM)
        {
          DBUG_PRINT("info",("spider child is FUNC_ITEM"));
          Item_func *ifunc = (Item_func *) item;
          if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
          {
            const char *child_func_name;
            int child_func_name_length;
            DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
            child_func_name = (char*) ifunc->func_name();
            child_func_name_length = strlen(child_func_name);
            DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
            if (
              child_func_name_length == 10 &&
              !strncasecmp("column_get", child_func_name, child_func_name_length)
            ) {
              DBUG_PRINT("info",("spider this is merge func"));
              merge_func = TRUE;
            }
          }
        }

        if (str)
        {
          char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;
          spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
          tmp_str.init_calc_mem(125);
          tmp_str.length(0);
          str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
          if (!merge_func)
          {
            if (str->reserve(SPIDER_SQL_CAST_LEN))
              DBUG_RETURN(HA_ERR_OUT_OF_MEM);
            str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
          }
#if MYSQL_VERSION_ID < 50500
          item_func->print(tmp_str.get_str(), QT_IS);
#else
          item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET);
#endif
          tmp_str.mem_calc();
          if (tmp_str.reserve(1))
            DBUG_RETURN(HA_ERR_OUT_OF_MEM);
          tmp_ptr = tmp_str.c_ptr_quick();
          DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));
          while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_CHAR_STR)))
            tmp_ptr = tmp_ptr2 + 1;
          last_str = tmp_ptr - 1;
          last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;
        }
      }
      break;
    case Item_func::NOT_FUNC:
      DBUG_PRINT("info",("spider NOT_FUNC"));
      if (item_list[0]->type() == Item::COND_ITEM)
      {
        DBUG_PRINT("info",("spider item_list[0] is COND_ITEM"));
        Item_cond *item_cond = (Item_cond *) item_list[0];
        if (item_cond->functype() == Item_func::COND_AND_FUNC)
        {
          DBUG_PRINT("info",("spider item_cond is COND_AND_FUNC"));
          List_iterator_fast<Item> lif(*(item_cond->argument_list()));
          bool has_expr_cache_item = FALSE;
          bool has_isnotnull_func = FALSE;
          bool has_other_item = FALSE;
          while((item = lif++))
          {
#ifdef SPIDER_HAS_EXPR_CACHE_ITEM
            if (
              item->type() == Item::EXPR_CACHE_ITEM
            ) {
              DBUG_PRINT("info",("spider EXPR_CACHE_ITEM"));
              has_expr_cache_item = TRUE;
            } else
#endif
            if (
              item->type() == Item::FUNC_ITEM &&
              ((Item_func *) item)->functype() == Item_func::ISNOTNULL_FUNC
            ) {
              DBUG_PRINT("info",("spider ISNOTNULL_FUNC"));
              has_isnotnull_func = TRUE;
            } else {
              DBUG_PRINT("info",("spider has other item"));
              DBUG_PRINT("info",("spider COND type=%d", item->type()));
              has_other_item = TRUE;
            }
          }
          if (has_expr_cache_item && has_isnotnull_func && !has_other_item)
          {
            DBUG_PRINT("info",("spider NOT EXISTS skip"));
            DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
          }
        }
      }
      if (str)
      {
        func_name = (char*) item_func->func_name();
        func_name_length = strlen(func_name);
        if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
        str->q_append(func_name, func_name_length);
        str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
      }
      break;
    case Item_func::NEG_FUNC:
      if (str)
      {
        func_name = (char*) item_func->func_name();
        func_name_length = strlen(func_name);
        if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
        str->q_append(func_name, func_name_length);
        str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
      }
      break;
    case Item_func::IN_FUNC:
      if (((Item_func_opt_neg *) item_func)->negated)
      {
        func_name = SPIDER_SQL_NOT_IN_STR;
        func_name_length = SPIDER_SQL_NOT_IN_LEN;
        separator_str = SPIDER_SQL_COMMA_STR;
        separator_str_length = SPIDER_SQL_COMMA_LEN;
        last_str = SPIDER_SQL_CLOSE_PAREN_STR;
        last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
      } else {
        func_name = SPIDER_SQL_IN_STR;
        func_name_length = SPIDER_SQL_IN_LEN;
        separator_str = SPIDER_SQL_COMMA_STR;
        separator_str_length = SPIDER_SQL_COMMA_LEN;
        last_str = SPIDER_SQL_CLOSE_PAREN_STR;
        last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
      }
      break;
    case Item_func::BETWEEN:
      if (((Item_func_opt_neg *) item_func)->negated)
      {
        func_name = SPIDER_SQL_NOT_BETWEEN_STR;
        func_name_length = SPIDER_SQL_NOT_BETWEEN_LEN;
        separator_str = SPIDER_SQL_AND_STR;
        separator_str_length = SPIDER_SQL_AND_LEN;
      } else {
        func_name = (char*) item_func->func_name();
        func_name_length = strlen(func_name);
        separator_str = SPIDER_SQL_AND_STR;
        separator_str_length = SPIDER_SQL_AND_LEN;
      }
      break;
    case Item_func::UDF_FUNC:
      use_pushdown_udf = spider_param_use_pushdown_udf(spider->trx->thd,
        spider->share->use_pushdown_udf);
      if (!use_pushdown_udf)
        DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
      if (str)
      {
        func_name = (char*) item_func->func_name();
        func_name_length = strlen(func_name);
        DBUG_PRINT("info",("spider func_name = %s", func_name));
        DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
        if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
        str->q_append(func_name, func_name_length);
        str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
      }
      func_name = SPIDER_SQL_COMMA_STR;
      func_name_length = SPIDER_SQL_COMMA_LEN;
      separator_str = SPIDER_SQL_COMMA_STR;
      separator_str_length = SPIDER_SQL_COMMA_LEN;
      last_str = SPIDER_SQL_CLOSE_PAREN_STR;
      last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
      break;
#ifdef MARIADB_BASE_VERSION
    case Item_func::XOR_FUNC:
#else
    case Item_func::COND_XOR_FUNC:
#endif
      if (str)
        str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
      DBUG_RETURN(
        spider_db_open_item_cond((Item_cond *) item_func, spider, str,
          alias, alias_length, dbton_id, use_fields, fields));
    case Item_func::TRIG_COND_FUNC:
      DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
    case Item_func::GUSERVAR_FUNC:
      if (str)
        str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
      if (item_func->result_type() == STRING_RESULT)
        DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
          alias, alias_length, dbton_id, use_fields, fields));
      else
        DBUG_RETURN(spider_db_open_item_int(item_func, NULL, spider, str,
          alias, alias_length, dbton_id, use_fields, fields));
    case Item_func::FT_FUNC:
      if (spider_db_check_ft_idx(item_func, spider) == MAX_KEY)
        DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
      start_item = 1;
      if (str)
      {
        if (str->reserve(SPIDER_SQL_MATCH_LEN))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
        str->q_append(SPIDER_SQL_MATCH_STR, SPIDER_SQL_MATCH_LEN);
      }
      separator_str = SPIDER_SQL_COMMA_STR;
      separator_str_length = SPIDER_SQL_COMMA_LEN;
      last_str = SPIDER_SQL_CLOSE_PAREN_STR;
      last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
      break;
    case Item_func::SP_EQUALS_FUNC:
      if (str)
      {
        func_name = SPIDER_SQL_MBR_EQUAL_STR;
        func_name_length = SPIDER_SQL_MBR_EQUAL_LEN;
        DBUG_PRINT("info",("spider func_name = %s", func_name));
        DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
        if (str->reserve(func_name_length))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
        str->q_append(func_name, func_name_length);
      }
      func_name = SPIDER_SQL_COMMA_STR;
      func_name_length = SPIDER_SQL_COMMA_LEN;
      separator_str = SPIDER_SQL_COMMA_STR;
      separator_str_length = SPIDER_SQL_COMMA_LEN;
      last_str = SPIDER_SQL_CLOSE_PAREN_STR;
      last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
      break;
    case Item_func::SP_DISJOINT_FUNC:
    case Item_func::SP_INTERSECTS_FUNC:
    case Item_func::SP_TOUCHES_FUNC:
    case Item_func::SP_CROSSES_FUNC:
    case Item_func::SP_WITHIN_FUNC:
    case Item_func::SP_CONTAINS_FUNC:
    case Item_func::SP_OVERLAPS_FUNC:
      if (str)
      {
        func_name = (char*) item_func->func_name();
        func_name_length = strlen(func_name);
        DBUG_PRINT("info",("spider func_name = %s", func_name));
        DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
        if (str->reserve(
#ifndef SPIDER_ITEM_GEOFUNC_NAME_HAS_MBR
          SPIDER_SQL_MBR_LEN +
#endif
          func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
#ifndef SPIDER_ITEM_GEOFUNC_NAME_HAS_MBR
        str->q_append(SPIDER_SQL_MBR_STR, SPIDER_SQL_MBR_LEN);
#endif
        str->q_append(func_name, func_name_length);
        str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
      }
      func_name = SPIDER_SQL_COMMA_STR;
      func_name_length = SPIDER_SQL_COMMA_LEN;
      separator_str = SPIDER_SQL_COMMA_STR;
      separator_str_length = SPIDER_SQL_COMMA_LEN;
      last_str = SPIDER_SQL_CLOSE_PAREN_STR;
      last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
      break;
    case Item_func::EQ_FUNC:
    case Item_func::EQUAL_FUNC:
    case Item_func::NE_FUNC:
    case Item_func::LT_FUNC:
    case Item_func::LE_FUNC:
    case Item_func::GE_FUNC:
    case Item_func::GT_FUNC:
    case Item_func::LIKE_FUNC:
      if (str)
      {
        func_name = (char*) item_func->func_name();
        func_name_length = strlen(func_name);
      }
      break;
    default:
      THD *thd = spider->trx->thd;
      SPIDER_SHARE *share = spider->share;
      if (spider_param_skip_default_condition(thd,
        share->skip_default_condition))
        DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
      if (str)
      {
        func_name = (char*) item_func->func_name();
        func_name_length = strlen(func_name);
      }
      break;
  }
  DBUG_PRINT("info",("spider func_name = %s", func_name));
  DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
  DBUG_PRINT("info",("spider separator_str = %s", separator_str));
  DBUG_PRINT("info",("spider separator_str_length = %d", separator_str_length));
  DBUG_PRINT("info",("spider last_str = %s", last_str));
  DBUG_PRINT("info",("spider last_str_length = %d", last_str_length));
  if (item_count)
  {
    item_count--;
    for (roop_count = start_item; roop_count < item_count; roop_count++)
    {
      item = item_list[roop_count];
      if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
        alias, alias_length, dbton_id, use_fields, fields)))
        DBUG_RETURN(error_num);
      if (roop_count == 1)
      {
        func_name = separator_str;
        func_name_length = separator_str_length;
      }
      if (str)
      {
        if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN * 2))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
        str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
        str->q_append(func_name, func_name_length);
        str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
      }
    }
    item = item_list[roop_count];
    if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
      alias, alias_length, dbton_id, use_fields, fields)))
      DBUG_RETURN(error_num);
  }
  if (item_func->functype() == Item_func::FT_FUNC)
  {
    Item_func_match *item_func_match = (Item_func_match *)item_func;
    if (str)
    {
      if (str->reserve(SPIDER_SQL_AGAINST_LEN))
        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
      str->q_append(SPIDER_SQL_AGAINST_STR, SPIDER_SQL_AGAINST_LEN);
    }
    item = item_list[0];
    if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
      alias, alias_length, dbton_id, use_fields, fields)))
      DBUG_RETURN(error_num);
    if (str)
    {
      if (str->reserve(
        ((item_func_match->flags & FT_BOOL) ?
          SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) +
        ((item_func_match->flags & FT_EXPAND) ?
          SPIDER_SQL_WITH_QUERY_EXPANSION_LEN : 0)
      ))
        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
      if (item_func_match->flags & FT_BOOL)
        str->q_append(SPIDER_SQL_IN_BOOLEAN_MODE_STR,
          SPIDER_SQL_IN_BOOLEAN_MODE_LEN);
      if (item_func_match->flags & FT_EXPAND)
        str->q_append(SPIDER_SQL_WITH_QUERY_EXPANSION_STR,
          SPIDER_SQL_WITH_QUERY_EXPANSION_LEN);
    }
  } else if (item_func->functype() == Item_func::UNKNOWN_FUNC)
  {
    if (
      func_name_length == 7 &&
      !strncasecmp("convert", func_name, func_name_length)
    ) {
      if (str)
      {
        Item_func_conv_charset *item_func_conv_charset =
          (Item_func_conv_charset *)item_func;
        CHARSET_INFO *conv_charset =
          item_func_conv_charset->SPIDER_Item_func_conv_charset_conv_charset;
        uint cset_length = strlen(conv_charset->csname);
        if (str->reserve(SPIDER_SQL_USING_LEN + cset_length))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
        str->q_append(SPIDER_SQL_USING_STR, SPIDER_SQL_USING_LEN);
        str->q_append(conv_charset->csname, cset_length);
      }
    }
  }
  if (str)
  {
    if (merge_func)
      str->length(str->length() - SPIDER_SQL_CLOSE_PAREN_LEN);
    if (str->reserve(last_str_length + SPIDER_SQL_CLOSE_PAREN_LEN))
      DBUG_RETURN(HA_ERR_OUT_OF_MEM);
    str->q_append(last_str, last_str_length);
    str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
  }
  DBUG_RETURN(0);
}

#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int spider_db_handlersocket_util::open_item_sum_func(
  Item_sum *item_sum,
  ha_spider *spider,
  spider_string *str,
  const char *alias,
  uint alias_length,
  bool use_fields,
  spider_fields *fields
) {
  uint dbton_id = spider_dbton_handlersocket.dbton_id;
  uint roop_count, item_count = item_sum->get_arg_count();
  int error_num;
  DBUG_ENTER("spider_db_handlersocket_util::open_item_sum_func");
  DBUG_PRINT("info",("spider Sumfunctype = %d", item_sum->sum_func()));
  switch (item_sum->sum_func())
  {
    case Item_sum::COUNT_FUNC:
    case Item_sum::SUM_FUNC:
    case Item_sum::MIN_FUNC:
    case Item_sum::MAX_FUNC:
      {
        const char *func_name = item_sum->func_name();
        uint func_name_length = strlen(func_name);
        Item *item, **args = item_sum->get_args();
        if (str)
        {
          if (str->reserve(func_name_length))
            DBUG_RETURN(HA_ERR_OUT_OF_MEM);
          str->q_append(func_name, func_name_length);
        }
        if (item_count)
        {
          item_count--;
          for (roop_count = 0; roop_count < item_count; roop_count++)
          {
            item = args[roop_count];
            if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
              alias, alias_length, dbton_id, use_fields, fields)))
              DBUG_RETURN(error_num);
            if (str)
            {
              if (str->reserve(SPIDER_SQL_COMMA_LEN))
                DBUG_RETURN(HA_ERR_OUT_OF_MEM);
              str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
            }
          }
          item = args[roop_count];
          if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
            alias, alias_length, dbton_id, use_fields, fields)))
            DBUG_RETURN(error_num);
        }
        if (str)
        {
          if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
            DBUG_RETURN(HA_ERR_OUT_OF_MEM);
          str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
            SPIDER_SQL_CLOSE_PAREN_LEN);
        }
      }
      break;
    case Item_sum::COUNT_DISTINCT_FUNC:
    case Item_sum::SUM_DISTINCT_FUNC:
    case Item_sum::AVG_FUNC:
    case Item_sum::AVG_DISTINCT_FUNC:
    case Item_sum::STD_FUNC:
    case Item_sum::VARIANCE_FUNC:
    case Item_sum::SUM_BIT_FUNC:
    case Item_sum::UDF_SUM_FUNC:
    case Item_sum::GROUP_CONCAT_FUNC:
    default:
      DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
  }
  DBUG_RETURN(0);
}
#endif

int spider_db_handlersocket_util::append_escaped_util(
  spider_string *to,
  String *from
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_escaped_util");
  DBUG_PRINT("info",("spider this=%p", this));
  to->append_escape_string(from->ptr(), from->length());
  DBUG_RETURN(0);
}

#ifdef SPIDER_HAS_GROUP_BY_HANDLER
int spider_db_handlersocket_util::append_from_and_tables(
  ha_spider *spider,
  spider_fields *fields,
  spider_string *str,
  TABLE_LIST *table_list,
  uint table_count
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_from_and_tables");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::reappend_tables(
  spider_fields *fields,
  SPIDER_LINK_IDX_CHAIN *link_idx_chain,
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket_util::reappend_tables");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_where(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_where");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_db_handlersocket_util::append_having(
  spider_string *str
) {
  DBUG_ENTER("spider_db_handlersocket_util::append_having");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}
#endif

spider_handlersocket_share::spider_handlersocket_share(
  st_spider_share *share
) : spider_db_share(
  share,
  spider_dbton_handlersocket.dbton_id
),
  table_names_str(NULL),
  db_names_str(NULL),
  db_table_str(NULL),
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
  db_table_str_hash_value(NULL),
#endif
  table_nm_max_length(0),
  db_nm_max_length(0),
  column_name_str(NULL),
  same_db_table_name(TRUE),
  first_all_link_idx(-1)
{
  DBUG_ENTER("spider_handlersocket_share::spider_handlersocket_share");
  DBUG_PRINT("info",("spider this=%p", this));
  spider_alloc_calc_mem_init(mem_calc, 186);
  spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this));
  DBUG_VOID_RETURN;
}

spider_handlersocket_share::~spider_handlersocket_share()
{
  DBUG_ENTER("spider_handlersocket_share::~spider_handlersocket_share");
  DBUG_PRINT("info",("spider this=%p", this));
  free_column_name_str();
  free_table_names_str();
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
  if (db_table_str_hash_value)
  {
    spider_free(spider_current_trx, db_table_str_hash_value, MYF(0));
  }
#endif
  spider_free_mem_calc(spider_current_trx, mem_calc_id, sizeof(*this));
  DBUG_VOID_RETURN;
}

int spider_handlersocket_share::init()
{
  int error_num;
  DBUG_ENTER("spider_handlersocket_share::init");
  DBUG_PRINT("info",("spider this=%p", this));
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
  if (!(db_table_str_hash_value = (my_hash_value_type *)
    spider_bulk_alloc_mem(spider_current_trx, 203,
      __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL),
      &db_table_str_hash_value,
        sizeof(my_hash_value_type) * spider_share->all_link_count,
      NullS))
  ) {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
#endif

  if (
    (error_num = create_table_names_str()) ||
    (
      spider_share->table_share &&
      (error_num = create_column_name_str())
    )
  ) {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_share::append_table_name(
  spider_string *str,
  int all_link_idx
) {
  const char *db_nm = db_names_str[all_link_idx].ptr();
  uint db_nm_len = db_names_str[all_link_idx].length();
  const char *table_nm = table_names_str[all_link_idx].ptr();
  uint table_nm_len = table_names_str[all_link_idx].length();
  DBUG_ENTER("spider_handlersocket_share::append_table_name");
  DBUG_PRINT("info",("spider this=%p", this));
  if (str->reserve(db_nm_len + SPIDER_SQL_DOT_LEN + table_nm_len +
    /* SPIDER_SQL_NAME_QUOTE_LEN */ 4))
  {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
  spider_db_handlersocket_utility.append_name(str, db_nm, db_nm_len);
  str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN);
  spider_db_handlersocket_utility.append_name(str, table_nm, table_nm_len);
  DBUG_RETURN(0);
}

int spider_handlersocket_share::create_table_names_str()
{
  int error_num, roop_count;
  uint table_nm_len, db_nm_len;
  spider_string *str, *first_tbl_nm_str, *first_db_nm_str, *first_db_tbl_str;
  char *first_tbl_nm, *first_db_nm;
  uint dbton_id = spider_dbton_handlersocket.dbton_id;
  DBUG_ENTER("spider_handlersocket_share::create_table_names_str");
  table_names_str = NULL;
  db_names_str = NULL;
  db_table_str = NULL;
  if (
    !(table_names_str = new spider_string[spider_share->all_link_count]) ||
    !(db_names_str = new spider_string[spider_share->all_link_count]) ||
    !(db_table_str = new spider_string[spider_share->all_link_count])
  ) {
    error_num = HA_ERR_OUT_OF_MEM;
    goto error;
  }

  same_db_table_name = TRUE;
  first_tbl_nm = spider_share->tgt_table_names[0];
  first_db_nm = spider_share->tgt_dbs[0];
  table_nm_len = spider_share->tgt_table_names_lengths[0];
  db_nm_len = spider_share->tgt_dbs_lengths[0];
  first_tbl_nm_str = &table_names_str[0];
  first_db_nm_str = &db_names_str[0];
  first_db_tbl_str = &db_table_str[0];
  for (roop_count = 0; roop_count < (int) spider_share->all_link_count;
    roop_count++)
  {
    table_names_str[roop_count].init_calc_mem(86);
    db_names_str[roop_count].init_calc_mem(87);
    db_table_str[roop_count].init_calc_mem(88);
    if (spider_share->sql_dbton_ids[roop_count] != dbton_id)
      continue;
    if (first_all_link_idx == -1)
      first_all_link_idx = roop_count;

    str = &table_names_str[roop_count];
    if (
      roop_count != 0 &&
      same_db_table_name &&
      spider_share->tgt_table_names_lengths[roop_count] == table_nm_len &&
      !memcmp(first_tbl_nm, spider_share->tgt_table_names[roop_count],
        table_nm_len)
    ) {
      if (str->copy(*first_tbl_nm_str))
      {
        error_num = HA_ERR_OUT_OF_MEM;
        goto error;
      }
    } else {
      str->set_charset(spider_share->access_charset);
      if ((error_num = spider_db_append_name_with_quote_str(str,
        spider_share->tgt_table_names[roop_count], dbton_id)))
        goto error;
      if (roop_count)
      {
        same_db_table_name = FALSE;
        DBUG_PRINT("info", ("spider found different table name %s",
          spider_share->tgt_table_names[roop_count]));
        if (str->length() > table_nm_max_length)
          table_nm_max_length = str->length();
      } else
        table_nm_max_length = str->length();
    }

    str = &db_names_str[roop_count];
    if (
      roop_count != 0 &&
      same_db_table_name &&
      spider_share->tgt_dbs_lengths[roop_count] == db_nm_len &&
      !memcmp(first_db_nm, spider_share->tgt_dbs[roop_count],
        db_nm_len)
    ) {
      if (str->copy(*first_db_nm_str))
      {
        error_num = HA_ERR_OUT_OF_MEM;
        goto error;
      }
    } else {
      str->set_charset(spider_share->access_charset);
      if ((error_num = spider_db_append_name_with_quote_str(str,
        spider_share->tgt_dbs[roop_count], dbton_id)))
        goto error;
      if (roop_count)
      {
        same_db_table_name = FALSE;
        DBUG_PRINT("info", ("spider found different db name %s",
          spider_share->tgt_dbs[roop_count]));
        if (str->length() > db_nm_max_length)
          db_nm_max_length = str->length();
      } else
        db_nm_max_length = str->length();
    }

    str = &db_table_str[roop_count];
    if (
      roop_count != 0 &&
      same_db_table_name
    ) {
      if (str->copy(*first_db_tbl_str))
      {
        error_num = HA_ERR_OUT_OF_MEM;
        goto error;
      }
    } else {
      str->set_charset(spider_share->access_charset);
      if ((error_num = append_table_name(str, roop_count)))
        goto error;
    }
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
    db_table_str_hash_value[roop_count] = my_calc_hash(
      &spider_open_connections, (uchar*) str->ptr(), str->length());
#endif
  }
  DBUG_RETURN(0);

error:
  if (db_table_str)
  {
    delete [] db_table_str;
    db_table_str = NULL;
  }
  if (db_names_str)
  {
    delete [] db_names_str;
    db_names_str = NULL;
  }
  if (table_names_str)
  {
    delete [] table_names_str;
    table_names_str = NULL;
  }
  DBUG_RETURN(error_num);
}

void spider_handlersocket_share::free_table_names_str()
{
  DBUG_ENTER("spider_handlersocket_share::free_table_names_str");
  if (db_table_str)
  {
    delete [] db_table_str;
    db_table_str = NULL;
  }
  if (db_names_str)
  {
    delete [] db_names_str;
    db_names_str = NULL;
  }
  if (table_names_str)
  {
    delete [] table_names_str;
    table_names_str = NULL;
  }
  DBUG_VOID_RETURN;
}

int spider_handlersocket_share::create_column_name_str()
{
  spider_string *str;
  int error_num;
  Field **field;
  TABLE_SHARE *table_share = spider_share->table_share;
  uint dbton_id = spider_dbton_handlersocket.dbton_id;
  DBUG_ENTER("spider_handlersocket_share::create_column_name_str");
  if (
    table_share->fields &&
    !(column_name_str = new spider_string[table_share->fields])
  )
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  for (field = table_share->field, str = column_name_str;
   *field; field++, str++)
  {
    str->init_calc_mem(202);
    str->set_charset(spider_share->access_charset);
    if ((error_num = spider_db_append_name_with_quote_str(str,
      (*field)->field_name, dbton_id)))
      goto error;
  }
  DBUG_RETURN(0);

error:
  if (column_name_str)
  {
    delete [] column_name_str;
    column_name_str = NULL;
  }
  DBUG_RETURN(error_num);
}

void spider_handlersocket_share::free_column_name_str()
{
  DBUG_ENTER("spider_handlersocket_share::free_column_name_str");
  if (column_name_str)
  {
    delete [] column_name_str;
    column_name_str = NULL;
  }
  DBUG_VOID_RETURN;
}

uint spider_handlersocket_share::get_column_name_length(
  uint field_index
) {
  DBUG_ENTER("spider_handlersocket_share::get_column_name_length");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(column_name_str[field_index].length());
}

int spider_handlersocket_share::append_column_name(
  spider_string *str,
  uint field_index
) {
  int error_num;
  DBUG_ENTER("spider_handlersocket_share::append_column_name");
  DBUG_PRINT("info",("spider this=%p", this));
  error_num = spider_db_handlersocket_utility.append_name(str,
    column_name_str[field_index].ptr(), column_name_str[field_index].length());
  DBUG_RETURN(error_num);
}

int spider_handlersocket_share::append_column_name_with_alias(
  spider_string *str,
  uint field_index,
  const char *alias,
  uint alias_length
) {
  DBUG_ENTER("spider_handlersocket_share::append_column_name_with_alias");
  DBUG_PRINT("info",("spider this=%p", this));
  if (str->reserve(
    alias_length +
    column_name_str[field_index].length() +
    /* SPIDER_SQL_NAME_QUOTE_LEN */ 2))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  str->q_append(alias, alias_length);
  append_column_name(str, field_index);
  DBUG_RETURN(0);
}

bool spider_handlersocket_share::need_change_db_table_name()
{
  DBUG_ENTER("spider_handlersocket_share::need_change_db_table_name");
  DBUG_RETURN(!same_db_table_name);
}

#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int spider_handlersocket_share::discover_table_structure(
  SPIDER_TRX *trx,
  SPIDER_SHARE *spider_share,
  spider_string *str
) {
  DBUG_ENTER("spider_handlersocket_share::discover_table_structure");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(HA_ERR_WRONG_COMMAND);
}
#endif

spider_handlersocket_handler::spider_handlersocket_handler(
  ha_spider *spider,
  spider_handlersocket_share *db_share
) : spider_db_handler(
  spider,
  db_share
),
  handlersocket_share(db_share),
  link_for_hash(NULL)
{
  DBUG_ENTER("spider_handlersocket_handler::spider_handlersocket_handler");
  DBUG_PRINT("info",("spider this=%p", this));
  spider_alloc_calc_mem_init(mem_calc, 187);
  spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this));
  DBUG_VOID_RETURN;
}

spider_handlersocket_handler::~spider_handlersocket_handler()
{
  DBUG_ENTER("spider_handlersocket_handler::~spider_handlersocket_handler");
  DBUG_PRINT("info",("spider this=%p", this));
  if (link_for_hash)
  {
    spider_free(spider_current_trx, link_for_hash, MYF(0));
  }
  spider_free_mem_calc(spider_current_trx, mem_calc_id, sizeof(*this));
  DBUG_VOID_RETURN;
}

int spider_handlersocket_handler::init()
{
  st_spider_share *share = spider->share;
  TABLE *table = spider->get_table();
  DBUG_ENTER("spider_handlersocket_handler::init");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!(link_for_hash = (SPIDER_LINK_FOR_HASH *)
    spider_bulk_alloc_mem(spider_current_trx, 204,
      __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL),
      &link_for_hash,
        sizeof(SPIDER_LINK_FOR_HASH) * share->link_count,
      &minimum_select_bitmap,
        table ? sizeof(uchar) * no_bytes_in_map(table->read_set) : 0,
      NullS))
  ) {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
  uint roop_count;
  for (roop_count = 0; roop_count < share->link_count; roop_count++)
  {
    link_for_hash[roop_count].spider = spider;
    link_for_hash[roop_count].link_idx = roop_count;
    link_for_hash[roop_count].db_table_str =
      &handlersocket_share->db_table_str[roop_count];
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
    link_for_hash[roop_count].db_table_str_hash_value =
      handlersocket_share->db_table_str_hash_value[roop_count];
#endif
  }
  hs_sql.init_calc_mem(63);
  hs_sql.set_charset(share->access_charset);
  hs_keys.init();
  hs_upds.init();
  hs_strs.init();
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_index_hint(
  spider_string *str,
  int link_idx,
  ulong sql_type
  )
{
  DBUG_ENTER("spider_handlersocket_handler::append_index_hint");
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_table_name_with_adjusting(
  spider_string *str,
  int link_idx,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_table_name_with_adjusting");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_tmp_table_and_sql_for_bka(
  const key_range *start_key
) {
  DBUG_ENTER("spider_handlersocket_handler::append_tmp_table_and_sql_for_bka");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reuse_tmp_table_and_sql_for_bka()
{
  DBUG_ENTER("spider_handlersocket_handler::reuse_tmp_table_and_sql_for_bka");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_union_table_and_sql_for_bka(
  const key_range *start_key
) {
  DBUG_ENTER("spider_handlersocket_handler::append_union_table_and_sql_for_bka");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reuse_union_table_and_sql_for_bka()
{
  DBUG_ENTER("spider_handlersocket_handler::reuse_union_table_and_sql_for_bka");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_insert_for_recovery(
  ulong sql_type,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::append_insert_for_recovery");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_update(
  const TABLE *table,
  my_ptrdiff_t ptr_diff
) {
  DBUG_ENTER("spider_handlersocket_handler::append_update");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_update(
  const TABLE *table,
  my_ptrdiff_t ptr_diff,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::append_update");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_delete(
  const TABLE *table,
  my_ptrdiff_t ptr_diff
) {
  DBUG_ENTER("spider_handlersocket_handler::append_delete");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_delete(
  const TABLE *table,
  my_ptrdiff_t ptr_diff,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::append_delete");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_insert_part()
{
  DBUG_ENTER("spider_handlersocket_handler::append_insert_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_update_part()
{
  DBUG_ENTER("spider_handlersocket_handler::append_update_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_delete_part()
{
  DBUG_ENTER("spider_handlersocket_handler::append_delete_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int spider_handlersocket_handler::append_increment_update_set_part()
{
  DBUG_ENTER("spider_handlersocket_handler::append_increment_update_set_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}
#endif

int spider_handlersocket_handler::append_update_set_part()
{
  DBUG_ENTER("spider_handlersocket_handler::append_update_set_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int spider_handlersocket_handler::append_direct_update_set_part()
{
  SPIDER_SHARE *share = spider->share;
  DBUG_ENTER("spider_handlersocket_handler::append_direct_update_set_part");
  if (
    spider->do_direct_update &&
    (spider->direct_update_kinds & SPIDER_SQL_KIND_HS)
  ) {
    DBUG_PRINT("info",("spider add set for DU SPIDER_SQL_KIND_HS"));
    size_t roop_count;
    Field *field;
    hs_adding_keys = FALSE;
    for (roop_count = 0; roop_count < spider->hs_pushed_ret_fields_num;
      roop_count++)
    {
      Field *top_table_field =
        spider->get_top_table_field(spider->hs_pushed_ret_fields[roop_count]);
      if (!(field = spider->field_exchange(top_table_field)))
        continue;
      if (top_table_field->is_null())
      {
        hs_upds.push_back(spider_null_string_ref);
      } else {
        if (spider_db_handlersocket_utility.
          append_column_value(spider, NULL, top_table_field, NULL,
            share->access_charset))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
      }
    }
  }
  DBUG_RETURN(0);
}
#endif

int spider_handlersocket_handler::append_minimum_select_without_quote(
  spider_string *str
) {
  TABLE *table = spider->get_table();
  Field **field;
  int field_length;
  bool appended = FALSE;
  DBUG_ENTER("spider_handlersocket_handler::append_minimum_select_without_quote");
  minimum_select_bitmap_create();
  for (field = table->field; *field; field++)
  {
    if (minimum_select_bit_is_set((*field)->field_index))
    {
/*
      spider_set_bit(minimum_select_bitmap, (*field)->field_index);
*/
      field_length =
        handlersocket_share->column_name_str[(*field)->field_index].length();
      if (str->reserve(field_length + SPIDER_SQL_COMMA_LEN))
        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
      str->q_append(
        handlersocket_share->column_name_str[(*field)->field_index].ptr(),
        handlersocket_share->column_name_str[(*field)->field_index].length());
      str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
      appended = TRUE;
    }
  }
  if (appended)
    str->length(str->length() - SPIDER_SQL_COMMA_LEN);
  DBUG_RETURN(0);
}

#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int spider_handlersocket_handler::append_minimum_select_by_field_idx_list(
  spider_string *str,
  uint32 *field_idxs,
  size_t field_idxs_num
) {
  Field *field;
  int roop_count, field_length;
  bool appended = FALSE;
  DBUG_ENTER("spider_handlersocket_handler::append_minimum_select_by_field_idx_list");
  for (roop_count = 0; roop_count < (int) field_idxs_num; roop_count++)
  {
    field = spider->get_top_table_field(field_idxs[roop_count]);
    if ((field = spider->field_exchange(field)))
    {
      field_length =
        handlersocket_share->column_name_str[field->field_index].length();
      if (str->reserve(field_length + SPIDER_SQL_COMMA_LEN))
        DBUG_RETURN(HA_ERR_OUT_OF_MEM);
      str->q_append(
        handlersocket_share->column_name_str[field->field_index].ptr(),
        handlersocket_share->column_name_str[field->field_index].length());
      str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
      appended = TRUE;
    }
  }
  if (appended)
    str->length(str->length() - SPIDER_SQL_COMMA_LEN);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_dup_update_pushdown_part(
  const char *alias,
  uint alias_length
) {
  DBUG_ENTER("spider_handlersocket_handler::append_dup_update_pushdown_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_update_columns_part(
  const char *alias,
  uint alias_length
) {
  DBUG_ENTER("spider_handlersocket_handler::append_update_columns_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::check_update_columns_part()
{
  DBUG_ENTER("spider_handlersocket_handler::check_update_columns_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}
#endif

int spider_handlersocket_handler::append_select_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_select_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_table_select_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_table_select_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_key_select_part(
  ulong sql_type,
  uint idx
) {
  DBUG_ENTER("spider_handlersocket_handler::append_key_select_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_minimum_select_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_minimum_select_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_hint_after_table_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_hint_after_table_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

void spider_handlersocket_handler::set_where_pos(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::set_where_pos");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_VOID_RETURN;
}

void spider_handlersocket_handler::set_where_to_pos(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::set_where_to_pos");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_VOID_RETURN;
}

int spider_handlersocket_handler::check_item_type(
  Item *item
) {
  DBUG_ENTER("spider_handlersocket_handler::check_item_type");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_values_connector_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_values_connector_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_values_terminator_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_values_terminator_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_union_table_connector_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_union_table_connector_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_union_table_terminator_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_union_table_terminator_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_key_column_values_part(
  const key_range *start_key,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_key_column_values_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_key_column_values_with_name_part(
  const key_range *start_key,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_key_column_values_with_name_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_key_where_part(
  const key_range *start_key,
  const key_range *end_key,
  ulong sql_type
) {
  int error_num;
  spider_string *str;
  bool set_order;
  DBUG_ENTER("spider_handlersocket_handler::append_key_where_part");
  switch (sql_type)
  {
    case SPIDER_SQL_TYPE_SELECT_HS:
    case SPIDER_SQL_TYPE_INSERT_HS:
    case SPIDER_SQL_TYPE_UPDATE_HS:
    case SPIDER_SQL_TYPE_DELETE_HS:
      str = &hs_sql;
      str->length(0);
      hs_adding_keys = TRUE;
      set_order = FALSE;
      break;
    default:
      DBUG_RETURN(0);
  }
  error_num = append_key_where(str, NULL, NULL, start_key, end_key,
    sql_type, set_order);
  DBUG_RETURN(error_num);
}

int spider_handlersocket_handler::append_key_where(
  spider_string *str,
  spider_string *str_part,
  spider_string *str_part2,
  const key_range *start_key,
  const key_range *end_key,
  ulong sql_type,
  bool set_order
) {
  int error_num;
  DBUG_ENTER("spider_handlersocket_handler::append_key_where");
  error_num = spider_db_append_key_where_internal(str, str_part, str_part2,
    start_key, end_key, spider, set_order, sql_type,
    spider_dbton_handlersocket.dbton_id);
  DBUG_RETURN(error_num);
}

int spider_handlersocket_handler::append_is_null_part(
  ulong sql_type,
  KEY_PART_INFO *key_part,
  const key_range *key,
  const uchar **ptr,
  bool key_eq,
  bool tgt_final
) {
  int error_num;
  spider_string *str;
  DBUG_ENTER("spider_handlersocket_handler::append_is_null_part");
  DBUG_PRINT("info",("spider this=%p", this));
  switch (sql_type)
  {
    case SPIDER_SQL_TYPE_SELECT_HS:
    case SPIDER_SQL_TYPE_INSERT_HS:
    case SPIDER_SQL_TYPE_UPDATE_HS:
    case SPIDER_SQL_TYPE_DELETE_HS:
      str = &hs_sql;
      break;
    default:
      DBUG_RETURN(0);
  }
  error_num = append_is_null(sql_type, str, NULL, NULL, key_part, key, ptr,
    key_eq, tgt_final);
  DBUG_RETURN(error_num);
}

int spider_handlersocket_handler::append_is_null(
  ulong sql_type,
  spider_string *str,
  spider_string *str_part,
  spider_string *str_part2,
  KEY_PART_INFO *key_part,
  const key_range *key,
  const uchar **ptr,
  bool key_eq,
  bool tgt_final
) {
  DBUG_ENTER("spider_handlersocket_handler::append_is_null");
  DBUG_PRINT("info",("spider this=%p", this));
  if (key_part->null_bit)
  {
    if (*(*ptr)++)
    {
      hs_keys.push_back(spider_null_string_ref);
      DBUG_RETURN(-1);
    }
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_where_terminator_part(
  ulong sql_type,
  bool set_order,
  int key_count
) {
  DBUG_ENTER("spider_handlersocket_handler::append_where_terminator_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_match_where_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_match_where_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_condition_part(
  const char *alias,
  uint alias_length,
  ulong sql_type,
  bool test_flg
) {
  DBUG_ENTER("spider_handlersocket_handler::append_condition_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_match_select_part(
  ulong sql_type,
  const char *alias,
  uint alias_length
) {
  DBUG_ENTER("spider_handlersocket_handler::append_match_select_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int spider_handlersocket_handler::append_sum_select_part(
  ulong sql_type,
  const char *alias,
  uint alias_length
) {
  DBUG_ENTER("spider_handlersocket_handler::append_sum_select_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}
#endif

void spider_handlersocket_handler::set_order_pos(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::set_order_pos");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_VOID_RETURN;
}

void spider_handlersocket_handler::set_order_to_pos(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::set_order_to_pos");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_VOID_RETURN;
}

#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int spider_handlersocket_handler::append_group_by_part(
  const char *alias,
  uint alias_length,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_group_by_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}
#endif

int spider_handlersocket_handler::append_key_order_for_merge_with_alias_part(
  const char *alias,
  uint alias_length,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_key_order_for_merge_with_alias_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_key_order_for_direct_order_limit_with_alias_part(
  const char *alias,
  uint alias_length,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_key_order_for_direct_order_limit_with_alias_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_key_order_with_alias_part(
  const char *alias,
  uint alias_length,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_key_order_with_alias_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_limit_part(
  longlong offset,
  longlong limit,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_limit_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_PRINT("info", ("spider offset=%lld", offset));
  DBUG_PRINT("info", ("spider limit=%lld", limit));
  hs_skip = (int) offset;
  hs_limit = (int) limit;
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reappend_limit_part(
  longlong offset,
  longlong limit,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::reappend_limit_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_select_lock_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_select_lock_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_union_all_start_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_union_all_start_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_union_all_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_union_all_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_union_all_end_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_union_all_end_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_multi_range_cnt_part(
  ulong sql_type,
  uint multi_range_cnt,
  bool with_comma
) {
  DBUG_ENTER("spider_handlersocket_handler::append_multi_range_cnt_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_multi_range_cnt_with_name_part(
  ulong sql_type,
  uint multi_range_cnt
) {
  DBUG_ENTER("spider_handlersocket_handler::append_multi_range_cnt_with_name_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_open_handler_part(
  ulong sql_type,
  uint handler_id,
  SPIDER_CONN *conn,
  int link_idx
) {
  int error_num;
  spider_string *str;
  DBUG_ENTER("spider_handlersocket_handler::append_open_handler_part");
  DBUG_PRINT("info",("spider this=%p", this));
  switch (sql_type)
  {
    case SPIDER_SQL_TYPE_OTHER_HS:
      str = &hs_sql;
      break;
    default:
      DBUG_RETURN(0);
  }
  error_num = append_open_handler(str, handler_id, conn, link_idx);
  DBUG_RETURN(error_num);
}

int spider_handlersocket_handler::append_open_handler(
  spider_string *str,
  uint handler_id,
  SPIDER_CONN *conn,
  int link_idx
) {
  int error_num;
  DBUG_ENTER("spider_handlersocket_handler::append_open_handler");
  DBUG_PRINT("info",("spider this=%p", this));
  if (
    str->length() == 0 &&
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
    (
      (
        (
          spider->sql_command == SQLCOM_HS_INSERT ||
          spider->hs_pushed_ret_fields_num == MAX_FIELDS
        ) &&
#endif
        (error_num = append_minimum_select_without_quote(str))
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
      ) ||
      (
        (
          spider->sql_command != SQLCOM_HS_INSERT &&
          spider->hs_pushed_ret_fields_num < MAX_FIELDS
        ) &&
        (error_num = append_minimum_select_by_field_idx_list(str,
          spider->hs_pushed_ret_fields, spider->hs_pushed_ret_fields_num))
      )
    )
#endif
  ) {
    DBUG_RETURN(error_num);
  }

  TABLE *table = spider->get_table();
  SPIDER_SHARE *share = spider->share;
  DBUG_PRINT("info",("spider field list=%s", str->c_ptr_safe()));
  if (!spider_bit_is_set(spider->db_request_phase, link_idx))
  {
    spider_set_bit(spider->db_request_phase, link_idx);
    ++spider->db_request_id[link_idx];
  }
  st_spider_db_request_key request_key;
  request_key.spider_thread_id = spider->trx->spider_thread_id;
  request_key.query_id = spider->trx->thd->query_id;
  request_key.handler = spider;
  request_key.request_id = spider->db_request_id[link_idx];
  request_key.next = NULL;
  conn->db_conn->append_open_handler(
    handler_id,
    share->tgt_dbs[spider->conn_link_idx[link_idx]],
    share->tgt_table_names[spider->conn_link_idx[link_idx]],
    spider->active_index < MAX_KEY ?
      table->key_info[spider->active_index].name :
      "0",
    str->c_ptr_safe(),
    &request_key
  );
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_close_handler_part(
  ulong sql_type,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::append_close_handler_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_insert_terminator_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_insert_terminator_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_insert_values_part(
  ulong sql_type
) {
  int error_num;
  spider_string *str;
  DBUG_ENTER("spider_mysql_handler::append_insert_values_part");
  DBUG_PRINT("info",("spider this=%p", this));
  switch (sql_type)
  {
    case SPIDER_SQL_TYPE_INSERT_HS:
      str = &hs_sql;
      break;
    default:
      DBUG_RETURN(0);
  }
  error_num = append_insert_values(str);
  DBUG_RETURN(error_num);
}

int spider_handlersocket_handler::append_insert_values(
  spider_string *str
) {
  SPIDER_SHARE *share = spider->share;
  TABLE *table = spider->get_table();
  Field **field;
  DBUG_ENTER("spider_mysql_handler::append_insert_values");
  DBUG_PRINT("info",("spider this=%p", this));
  hs_adding_keys = FALSE;
  for (field = table->field; *field; field++)
  {
    DBUG_PRINT("info",("spider field_index=%u", (*field)->field_index));
    if (
      bitmap_is_set(table->write_set, (*field)->field_index) ||
      bitmap_is_set(table->read_set, (*field)->field_index)
    ) {
#ifndef DBUG_OFF
      my_bitmap_map *tmp_map =
        dbug_tmp_use_all_columns(table, table->read_set);
#endif
      DBUG_PRINT("info",("spider is_null()=%s",
        (*field)->is_null() ? "TRUE" : "FALSE"));
      DBUG_PRINT("info",("spider table->next_number_field=%p",
        table->next_number_field));
      DBUG_PRINT("info",("spider *field=%p", *field));
      DBUG_PRINT("info",("spider force_auto_increment=%s",
        (table->next_number_field && spider->force_auto_increment) ?
        "TRUE" : "FALSE"));
      if (
        (*field)->is_null() ||
        (
          table->next_number_field == *field &&
          !table->auto_increment_field_not_null &&
          !spider->force_auto_increment
        )
      ) {
        hs_upds.push_back(spider_null_string_ref);
      } else {
        spider_db_handlersocket_utility.
          append_column_value(spider, NULL, *field, NULL,
            share->access_charset);
      }
#ifndef DBUG_OFF
      dbug_tmp_restore_column_map(table->read_set, tmp_map);
#endif
    }
  }
  int error_num;
  int roop_count2;
  for (
    roop_count2 = spider_conn_link_idx_next(share->link_statuses,
      spider->conn_link_idx, -1, share->link_count,
      SPIDER_LINK_STATUS_RECOVERY);
    roop_count2 < (int) share->link_count;
    roop_count2 = spider_conn_link_idx_next(share->link_statuses,
      spider->conn_link_idx, roop_count2, share->link_count,
      SPIDER_LINK_STATUS_RECOVERY)
  ) {
    if (spider->sql_kind[roop_count2] == SPIDER_SQL_KIND_HS)
    {
      SPIDER_CONN *conn = spider->hs_w_conns[roop_count2];
      if (conn->dbton_id == spider_dbton_handlersocket.dbton_id)
      {
        if ((error_num = request_buf_insert(roop_count2)))
          DBUG_RETURN(error_num);
#ifdef HA_CAN_BULK_ACCESS
        if (spider->is_bulk_access_clone)
        {
          spider->connection_ids[roop_count2] = conn->connection_id;
          spider_trx_add_bulk_access_conn(spider->trx, conn);
        }
#endif
      }
    }
  }
  hs_upds.clear();
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_into_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_into_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

void spider_handlersocket_handler::set_insert_to_pos(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::set_insert_to_pos");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_VOID_RETURN;
}

int spider_handlersocket_handler::append_from_part(
  ulong sql_type,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::append_from_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_delete_all_rows_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_delete_all_rows_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_explain_select_part(
  const key_range *start_key,
  const key_range *end_key,
  ulong sql_type,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::append_explain_select_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::is_sole_projection_field(
  uint16 field_index
) {
  DBUG_ENTER("spider_handlersocket_handler::is_sole_projection_field");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

bool spider_handlersocket_handler::is_bulk_insert_exec_period(
  bool bulk_end
) {
  DBUG_ENTER("spider_handlersocket_handler::is_bulk_insert_exec_period");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!spider->bulk_insert || bulk_end)
    DBUG_RETURN(TRUE);
  DBUG_RETURN(FALSE);
}

bool spider_handlersocket_handler::sql_is_filled_up(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::sql_is_filled_up");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(FALSE);
}

bool spider_handlersocket_handler::sql_is_empty(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::sql_is_empty");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(FALSE);
}

bool spider_handlersocket_handler::support_multi_split_read()
{
  DBUG_ENTER("spider_handlersocket_handler::support_multi_split_read");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(FALSE);
}

bool spider_handlersocket_handler::support_bulk_update()
{
  DBUG_ENTER("spider_handlersocket_handler::support_bulk_update");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(FALSE);
}

int spider_handlersocket_handler::bulk_tmp_table_insert()
{
  DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_insert");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::bulk_tmp_table_insert(
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_insert");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::bulk_tmp_table_end_bulk_insert()
{
  DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_end_bulk_insert");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::bulk_tmp_table_rnd_init()
{
  DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_rnd_init");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::bulk_tmp_table_rnd_next()
{
  DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_rnd_next");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::bulk_tmp_table_rnd_end()
{
  DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_rnd_end");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

bool spider_handlersocket_handler::need_copy_for_update(
    int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::need_copy_for_update");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(TRUE);
}

bool spider_handlersocket_handler::bulk_tmp_table_created()
{
  DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_created");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(FALSE);
}

int spider_handlersocket_handler::mk_bulk_tmp_table_and_bulk_start()
{
  DBUG_ENTER("spider_handlersocket_handler::mk_bulk_tmp_table_and_bulk_start");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

void spider_handlersocket_handler::rm_bulk_tmp_table()
{
  DBUG_ENTER("spider_handlersocket_handler::rm_bulk_tmp_table");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_VOID_RETURN;
}

int spider_handlersocket_handler::insert_lock_tables_list(
  SPIDER_CONN *conn,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::insert_lock_tables_list");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_lock_tables_list(
  SPIDER_CONN *conn,
  int link_idx,
  int *appended
) {
  DBUG_ENTER("spider_handlersocket_handler::append_lock_tables_list");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::realloc_sql(
  ulong *realloced
) {
  THD *thd = spider->trx->thd;
  st_spider_share *share = spider->share;
  int init_sql_alloc_size =
    spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
  DBUG_ENTER("spider_handlersocket_handler::realloc_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  if ((int) hs_sql.alloced_length() > init_sql_alloc_size * 2)
  {
    hs_sql.free();
    if (hs_sql.real_alloc(init_sql_alloc_size))
      DBUG_RETURN(HA_ERR_OUT_OF_MEM);
    *realloced |= SPIDER_SQL_TYPE_FULL_HS;
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reset_sql(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::reset_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
  {
    hs_sql.length(0);
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reset_keys(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::reset_keys");
  DBUG_PRINT("info",("spider this=%p", this));
  if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
  {
    hs_keys.clear();
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reset_upds(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::reset_upds");
  DBUG_PRINT("info",("spider this=%p", this));
  if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
  {
    hs_upds.clear();
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reset_strs(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::reset_strs");
  DBUG_PRINT("info",("spider this=%p", this));
  if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
  {
    hs_strs.clear();
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reset_strs_pos(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::reset_strs_pos");
  DBUG_PRINT("info",("spider this=%p", this));
  if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
  {
    hs_strs_pos = 0;
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::push_back_upds(
  SPIDER_HS_STRING_REF &info
) {
  int error_num;
  DBUG_ENTER("spider_handlersocket_handler::push_back_upds");
  DBUG_PRINT("info",("spider this=%p", this));
  error_num = hs_upds.push_back(info);
  DBUG_RETURN(error_num);
}

int spider_handlersocket_handler::request_buf_find(
  int link_idx
) {
  int error_num;
  spider_string *hs_str;
  SPIDER_CONN *conn;
  uint handler_id;
  DBUG_ENTER("spider_handlersocket_handler::request_buf_find");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!(hs_str = hs_strs.add(&hs_strs_pos, hs_sql.ptr(), hs_sql.length())))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  if (spider->conn_kind[link_idx] == SPIDER_CONN_KIND_HS_READ)
  {
    conn = spider->hs_r_conns[link_idx];
    handler_id = spider->r_handler_id[link_idx];
  } else {
    conn = spider->hs_w_conns[link_idx];
    handler_id = spider->w_handler_id[link_idx];
  }
  if ((error_num = spider_db_conn_queue_action(conn)))
    DBUG_RETURN(error_num);
  if (!spider_bit_is_set(spider->db_request_phase, link_idx))
  {
    spider_set_bit(spider->db_request_phase, link_idx);
    ++spider->db_request_id[link_idx];
  }
  st_spider_db_request_key request_key;
  request_key.spider_thread_id = spider->trx->spider_thread_id;
  request_key.query_id = spider->trx->thd->query_id;
  request_key.handler = spider;
  request_key.request_id = spider->db_request_id[link_idx];
  request_key.next = NULL;
  conn->db_conn->append_select(
    handler_id, hs_str, &hs_keys,
    hs_limit, hs_skip, &request_key);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::request_buf_insert(
  int link_idx
) {
  int error_num;
  DBUG_ENTER("spider_handlersocket_handler::request_buf_insert");
  DBUG_PRINT("info",("spider this=%p", this));
  if ((error_num = spider_db_conn_queue_action(spider->hs_w_conns[link_idx])))
    DBUG_RETURN(error_num);
  if (!spider_bit_is_set(spider->db_request_phase, link_idx))
  {
    spider_set_bit(spider->db_request_phase, link_idx);
    ++spider->db_request_id[link_idx];
  }
  st_spider_db_request_key request_key;
  request_key.spider_thread_id = spider->trx->spider_thread_id;
  request_key.query_id = spider->trx->thd->query_id;
  request_key.handler = spider;
  request_key.request_id = spider->db_request_id[link_idx];
  request_key.next = NULL;
  spider->hs_w_conns[link_idx]->db_conn->append_insert(
    spider->w_handler_id[link_idx], &hs_upds, &request_key);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::request_buf_update(
  int link_idx
) {
  int error_num;
  spider_string *hs_str;
  DBUG_ENTER("spider_handlersocket_handler::request_buf_update");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!(hs_str = hs_strs.add(&hs_strs_pos, hs_sql.ptr(), hs_sql.length())))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  if ((error_num = spider_db_conn_queue_action(spider->hs_w_conns[link_idx])))
    DBUG_RETURN(error_num);
  if (!spider_bit_is_set(spider->db_request_phase, link_idx))
  {
    spider_set_bit(spider->db_request_phase, link_idx);
    ++spider->db_request_id[link_idx];
  }
  st_spider_db_request_key request_key;
  request_key.spider_thread_id = spider->trx->spider_thread_id;
  request_key.query_id = spider->trx->thd->query_id;
  request_key.handler = spider;
  request_key.request_id = spider->db_request_id[link_idx];
  request_key.next = NULL;
  spider->hs_w_conns[link_idx]->db_conn->append_update(
    spider->w_handler_id[link_idx], hs_str, &hs_keys, &hs_upds,
    hs_limit, hs_skip,
    spider->hs_increment, spider->hs_decrement, &request_key
  );
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::request_buf_delete(
  int link_idx
) {
  int error_num;
  spider_string *hs_str;
  DBUG_ENTER("spider_handlersocket_handler::request_buf_delete");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!(hs_str = hs_strs.add(&hs_strs_pos, hs_sql.ptr(), hs_sql.length())))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  if ((error_num = spider_db_conn_queue_action(spider->hs_w_conns[link_idx])))
    DBUG_RETURN(error_num);
  if (!spider_bit_is_set(spider->db_request_phase, link_idx))
  {
    spider_set_bit(spider->db_request_phase, link_idx);
    ++spider->db_request_id[link_idx];
  }
  st_spider_db_request_key request_key;
  request_key.spider_thread_id = spider->trx->spider_thread_id;
  request_key.query_id = spider->trx->thd->query_id;
  request_key.handler = spider;
  request_key.request_id = spider->db_request_id[link_idx];
  request_key.next = NULL;
  spider->hs_w_conns[link_idx]->db_conn->append_delete(
    spider->w_handler_id[link_idx], hs_str, &hs_keys,
    hs_limit, hs_skip, &request_key);
  DBUG_RETURN(0);
}

bool spider_handlersocket_handler::need_lock_before_set_sql_for_exec(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::need_lock_before_set_sql_for_exec");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(TRUE);
}

#ifdef SPIDER_HAS_GROUP_BY_HANDLER
int spider_handlersocket_handler::set_sql_for_exec(
  ulong sql_type,
  int link_idx,
  SPIDER_LINK_IDX_CHAIN *link_idx_chain
) {
  DBUG_ENTER("spider_handlersocket_handler::set_sql_for_exec");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}
#endif

int spider_handlersocket_handler::set_sql_for_exec(
  ulong sql_type,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::set_sql_for_exec");
  DBUG_PRINT("info",("spider this=%p", this));
  if (sql_type & SPIDER_SQL_TYPE_SELECT_HS)
  {
    DBUG_RETURN(request_buf_find(link_idx));
  }
  if (sql_type & SPIDER_SQL_TYPE_INSERT_HS)
  {
    DBUG_RETURN(request_buf_insert(link_idx));
  }
  if (sql_type & SPIDER_SQL_TYPE_UPDATE_HS)
  {
    DBUG_RETURN(request_buf_update(link_idx));
  }
  if (sql_type & SPIDER_SQL_TYPE_DELETE_HS)
  {
    DBUG_RETURN(request_buf_delete(link_idx));
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::set_sql_for_exec(
  spider_db_copy_table *tgt_ct,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::set_sql_for_exec");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::execute_sql(
  ulong sql_type,
  SPIDER_CONN *conn,
  int quick_mode,
  int *need_mon
) {
  DBUG_ENTER("spider_handlersocket_handler::execute_sql");
  DBUG_PRINT("info",("spider this=%p", this));
  if (!(sql_type & SPIDER_SQL_TYPE_FULL_HS))
  {
    /* nothing to do */
    DBUG_RETURN(0);
  }
  DBUG_RETURN(spider_db_query(
    conn,
    NULL,
    0,
    quick_mode,
    need_mon
  ));
}

int spider_handlersocket_handler::reset()
{
  DBUG_ENTER("spider_handlersocket_handler::reset");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::sts_mode_exchange(
  int sts_mode
) {
  DBUG_ENTER("spider_handlersocket_handler::sts_mode_exchange");
  DBUG_PRINT("info",("spider sts_mode=%d", sts_mode));
  DBUG_RETURN(sts_mode);
}

int spider_handlersocket_handler::show_table_status(
  int link_idx,
  int sts_mode,
  uint flag
) {
  spider_db_handlersocket_result res(NULL);
  SPIDER_SHARE *share = spider->share;
  ulonglong auto_increment_value = 0;
  DBUG_ENTER("spider_handlersocket_show_table_status");
  res.fetch_table_status(
    sts_mode,
    share->stat
  );
  if (auto_increment_value > share->lgtm_tblhnd_share->auto_increment_value)
  {
    share->lgtm_tblhnd_share->auto_increment_value = auto_increment_value;
    DBUG_PRINT("info",("spider auto_increment_value=%llu",
      share->lgtm_tblhnd_share->auto_increment_value));
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::crd_mode_exchange(
  int crd_mode
) {
  DBUG_ENTER("spider_handlersocket_handler::crd_mode_exchange");
  DBUG_PRINT("info",("spider crd_mode=%d", crd_mode));
  DBUG_RETURN(crd_mode);
}

int spider_handlersocket_handler::show_index(
  int link_idx,
  int crd_mode
) {
  DBUG_ENTER("spider_handlersocket_handler::show_index");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::show_records(
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::show_records");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::show_last_insert_id(
  int link_idx,
  ulonglong &last_insert_id
) {
  DBUG_ENTER("spider_handlersocket_handler::show_last_insert_id");
  last_insert_id = 0;
  DBUG_RETURN(0);
}

ha_rows spider_handlersocket_handler::explain_select(
  key_range *start_key,
  key_range *end_key,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::explain_select");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::lock_tables(
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::lock_tables");
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::unlock_tables(
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::unlock_tables");
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::disable_keys(
  SPIDER_CONN *conn,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::disable_keys");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::enable_keys(
  SPIDER_CONN *conn,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::enable_keys");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::check_table(
  SPIDER_CONN *conn,
  int link_idx,
  HA_CHECK_OPT* check_opt
) {
  DBUG_ENTER("spider_handlersocket_handler::check_table");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::repair_table(
  SPIDER_CONN *conn,
  int link_idx,
  HA_CHECK_OPT* check_opt
) {
  DBUG_ENTER("spider_handlersocket_handler::repair_table");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::analyze_table(
  SPIDER_CONN *conn,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::analyze_table");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::optimize_table(
  SPIDER_CONN *conn,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::optimize_table");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::flush_tables(
  SPIDER_CONN *conn,
  int link_idx,
  bool lock
) {
  DBUG_ENTER("spider_handlersocket_handler::flush_tables");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::flush_logs(
  SPIDER_CONN *conn,
  int link_idx
) {
  DBUG_ENTER("spider_handlersocket_handler::flush_logs");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::insert_opened_handler(
  SPIDER_CONN *conn,
  int link_idx
) {
  spider_db_handlersocket *db_conn = (spider_db_handlersocket *) conn->db_conn;
  SPIDER_LINK_FOR_HASH *tmp_link_for_hash = &link_for_hash[link_idx];
  DBUG_ASSERT(tmp_link_for_hash->spider == spider);
  DBUG_ASSERT(tmp_link_for_hash->link_idx == link_idx);
  uint old_elements = db_conn->handler_open_array.max_element;
  DBUG_ENTER("spider_handlersocket_handler::insert_opened_handler");
  DBUG_PRINT("info",("spider this=%p", this));
  if (insert_dynamic(&db_conn->handler_open_array,
    (uchar*) &tmp_link_for_hash))
  {
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  }
  if (db_conn->handler_open_array.max_element > old_elements)
  {
    spider_alloc_calc_mem(spider_current_trx,
      db_conn->handler_open_array,
      (db_conn->handler_open_array.max_element - old_elements) *
      db_conn->handler_open_array.size_of_element);
  }
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::delete_opened_handler(
  SPIDER_CONN *conn,
  int link_idx
) {
  spider_db_handlersocket *db_conn = (spider_db_handlersocket *) conn->db_conn;
  uint roop_count, elements = db_conn->handler_open_array.elements;
  SPIDER_LINK_FOR_HASH *tmp_link_for_hash;
  DBUG_ENTER("spider_handlersocket_handler::delete_opened_handler");
  DBUG_PRINT("info",("spider this=%p", this));
  for (roop_count = 0; roop_count < elements; roop_count++)
  {
    get_dynamic(&db_conn->handler_open_array, (uchar *) &tmp_link_for_hash,
      roop_count);
    if (tmp_link_for_hash == &link_for_hash[link_idx])
    {
      delete_dynamic_element(&db_conn->handler_open_array, roop_count);
      break;
    }
  }
  DBUG_ASSERT(roop_count < elements);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::sync_from_clone_source(
  spider_db_handler *dbton_hdl
) {
  spider_handlersocket_handler *hs_hdl =
    (spider_handlersocket_handler *) dbton_hdl;
  DBUG_ENTER("spider_handlersocket_handler::sync_from_clone_source");
  DBUG_PRINT("info",("spider this=%p", this));
  hs_strs_pos = hs_hdl->hs_strs_pos;
  DBUG_RETURN(0);
}

bool spider_handlersocket_handler::support_use_handler(
  int use_handler
) {
  DBUG_ENTER("spider_handlersocket_handler::support_use_handler");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_RETURN(TRUE);
}

void spider_handlersocket_handler::minimum_select_bitmap_create()
{
  TABLE *table = spider->get_table();
  Field **field_p;
  DBUG_ENTER("spider_handlersocket_handler::minimum_select_bitmap_create");
  memset(minimum_select_bitmap, 0, no_bytes_in_map(table->read_set));
  if (
    spider->use_index_merge ||
#ifdef HA_CAN_BULK_ACCESS
    (spider->is_clone && !spider->is_bulk_access_clone)
#else
    spider->is_clone
#endif
  ) {
    /* need preparing for cmp_ref */
    TABLE_SHARE *table_share = table->s;
    if (
      table_share->primary_key == MAX_KEY
    ) {
      /* need all columns */
      memset(minimum_select_bitmap, 0xFF, no_bytes_in_map(table->read_set));
      DBUG_VOID_RETURN;
    } else {
      /* need primary key columns */
      uint roop_count;
      KEY *key_info;
      KEY_PART_INFO *key_part;
      Field *field;
      key_info = &table_share->key_info[table_share->primary_key];
      key_part = key_info->key_part;
      for (roop_count = 0;
        roop_count < spider_user_defined_key_parts(key_info);
        roop_count++)
      {
        field = key_part[roop_count].field;
        spider_set_bit(minimum_select_bitmap, field->field_index);
      }
    }
  }
  for (field_p = table->field; *field_p; field_p++)
  {
    uint field_index = (*field_p)->field_index;
    if (
      spider_bit_is_set(spider->searched_bitmap, field_index) ||
      bitmap_is_set(table->read_set, field_index) ||
      bitmap_is_set(table->write_set, field_index)
    ) {
      spider_set_bit(minimum_select_bitmap, field_index);
    }
  }
  DBUG_VOID_RETURN;
}

bool spider_handlersocket_handler::minimum_select_bit_is_set(
  uint field_index
) {
  DBUG_ENTER("spider_handlersocket_handler::minimum_select_bit_is_set");
  DBUG_PRINT("info",("spider field_index=%u", field_index));
  DBUG_PRINT("info",("spider minimum_select_bitmap=%s",
    spider_bit_is_set(minimum_select_bitmap, field_index) ?
      "TRUE" : "FALSE"));
  DBUG_RETURN(spider_bit_is_set(minimum_select_bitmap, field_index));
}

void spider_handlersocket_handler::copy_minimum_select_bitmap(
  uchar *bitmap
) {
  int roop_count;
  TABLE *table = spider->get_table();
  DBUG_ENTER("spider_handlersocket_handler::copy_minimum_select_bitmap");
  for (roop_count = 0;
    roop_count < (int) ((table->s->fields + 7) / 8);
    roop_count++)
  {
    bitmap[roop_count] =
      minimum_select_bitmap[roop_count];
    DBUG_PRINT("info",("spider roop_count=%d", roop_count));
    DBUG_PRINT("info",("spider bitmap=%d",
      bitmap[roop_count]));
  }
  DBUG_VOID_RETURN;
}

int spider_handlersocket_handler::init_union_table_name_pos()
{
  DBUG_ENTER("spider_handlersocket_handler::init_union_table_name_pos");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::set_union_table_name_pos()
{
  DBUG_ENTER("spider_handlersocket_handler::set_union_table_name_pos");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reset_union_table_name(
  spider_string *str,
  int link_idx,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::reset_union_table_name");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

#ifdef SPIDER_HAS_GROUP_BY_HANDLER
int spider_handlersocket_handler::append_list_item_select_part(
  List<Item> *select,
  const char *alias,
  uint alias_length,
  bool use_fields,
  spider_fields *fields,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_list_item_select_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_from_and_tables_part(
  spider_fields *fields,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_from_and_tables_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::reappend_tables_part(
  spider_fields *fields,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::reappend_tables_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_where_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_where_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_having_part(
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_having_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_item_type_part(
  Item *item,
  const char *alias,
  uint alias_length,
  bool use_fields,
  spider_fields *fields,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_item_type_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_group_by_part(
  ORDER *order,
  const char *alias,
  uint alias_length,
  bool use_fields,
  spider_fields *fields,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_group_by_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}

int spider_handlersocket_handler::append_order_by_part(
  ORDER *order,
  const char *alias,
  uint alias_length,
  bool use_fields,
  spider_fields *fields,
  ulong sql_type
) {
  DBUG_ENTER("spider_handlersocket_handler::append_order_by_part");
  DBUG_PRINT("info",("spider this=%p", this));
  DBUG_ASSERT(0);
  DBUG_RETURN(0);
}
#endif
#endif
