← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_class.cc

  • Committer: Stewart Smith
  • Date: 2008-09-25 10:04:06 UTC
  • mto: This revision was merged to the branch mainline in revision 408.
  • Revision ID: stewart@flamingspork.com-20080925100406-hld92f4dr4nuar3a
Move compression functions (compress, uncompress and compressed_length) out into modules and fix test

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_class.cc
59
59
** User variables
60
60
****************************************************************************/
61
61
 
62
 
extern "C" unsigned char *get_var_key(user_var_entry *entry, size_t *length,
 
62
extern "C" uchar *get_var_key(user_var_entry *entry, size_t *length,
63
63
                              bool not_used __attribute__((unused)))
64
64
{
65
65
  *length= entry->name.length;
66
 
  return (unsigned char*) entry->name.str;
 
66
  return (uchar*) entry->name.str;
67
67
}
68
68
 
69
69
extern "C" void free_user_var(user_var_entry *entry)
70
70
{
71
71
  char *pos= (char*) entry+ALIGN_SIZE(sizeof(*entry));
72
72
  if (entry->value && entry->value != pos)
73
 
    free(entry->value);
74
 
  free((char*) entry);
 
73
    my_free(entry->value, MYF(0));
 
74
  my_free((char*) entry,MYF(0));
75
75
}
76
76
 
77
77
bool Key_part_spec::operator==(const Key_part_spec& other) const
359
359
 
360
360
void
361
361
Diagnostics_area::set_error_status(THD *thd __attribute__((unused)),
362
 
                                   uint32_t sql_errno_arg,
 
362
                                   uint sql_errno_arg,
363
363
                                   const char *message_arg)
364
364
{
365
365
  /*
399
399
 
400
400
 
401
401
THD::THD()
402
 
   :Statement(&main_lex, &main_mem_root,
 
402
   :Statement(&main_lex, &main_mem_root, CONVENTIONAL_EXECUTION,
403
403
              /* statement id */ 0),
404
404
   Open_tables_state(refresh_version), rli_fake(0),
405
405
   lock_id(&main_lock_id),
429
429
    will be re-initialized in init_for_queries().
430
430
  */
431
431
  init_sql_alloc(&main_mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
 
432
  stmt_arena= this;
432
433
  thread_stack= 0;
433
434
  catalog= (char*)"std"; // the only catalog we have for now
434
435
  main_security_ctx.init();
463
464
  memset(ha_data, 0, sizeof(ha_data));
464
465
  mysys_var=0;
465
466
  binlog_evt_union.do_union= false;
 
467
  enable_slow_log= 0;
466
468
  dbug_sentry=THD_SENTRY_MAGIC;
467
469
  net.vio=0;
468
470
  client_capabilities= 0;                       // minimalistic client
522
524
}
523
525
 
524
526
 
525
 
bool THD::handle_error(uint32_t sql_errno, const char *message,
 
527
bool THD::handle_error(uint sql_errno, const char *message,
526
528
                       DRIZZLE_ERROR::enum_warning_level level)
527
529
{
528
530
  if (m_internal_handler)
676
678
  delete_dynamic(&user_var_events);
677
679
  hash_free(&user_vars);
678
680
  close_temporary_tables(this);
679
 
  free((char*) variables.time_format);
680
 
  free((char*) variables.date_format);
681
 
  free((char*) variables.datetime_format);
 
681
  my_free((char*) variables.time_format, MYF(MY_ALLOW_ZERO_PTR));
 
682
  my_free((char*) variables.date_format, MYF(MY_ALLOW_ZERO_PTR));
 
683
  my_free((char*) variables.datetime_format, MYF(MY_ALLOW_ZERO_PTR));
682
684
  
683
685
  if (global_read_lock)
684
686
    unlock_global_read_lock(this);
708
710
  plugin_thdvar_cleanup(this);
709
711
 
710
712
  main_security_ctx.destroy();
711
 
  if (db)
712
 
  {
713
 
    free(db);
714
 
    db= NULL;
715
 
  }
 
713
  safeFree(db);
716
714
  free_root(&warn_root,MYF(0));
717
715
  free_root(&transaction.mem_root,MYF(0));
718
716
  mysys_var=0;                                  // Safety (shouldn't be needed)
745
743
 
746
744
void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var)
747
745
{
748
 
  ulong *end= (ulong*) ((unsigned char*) to_var +
 
746
  ulong *end= (ulong*) ((uchar*) to_var +
749
747
                        offsetof(STATUS_VAR, last_system_status_var) +
750
748
                        sizeof(ulong));
751
749
  ulong *to= (ulong*) to_var, *from= (ulong*) from_var;
770
768
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
771
769
                        STATUS_VAR *dec_var)
772
770
{
773
 
  ulong *end= (ulong*) ((unsigned char*) to_var + offsetof(STATUS_VAR,
 
771
  ulong *end= (ulong*) ((uchar*) to_var + offsetof(STATUS_VAR,
774
772
                                                  last_system_status_var) +
775
773
                        sizeof(ulong));
776
774
  ulong *to= (ulong*) to_var, *from= (ulong*) from_var, *dec= (ulong*) dec_var;
922
920
  @return  NULL on failure, or pointer to the LEX_STRING object
923
921
*/
924
922
LEX_STRING *THD::make_lex_string(LEX_STRING *lex_str,
925
 
                                 const char* str, uint32_t length,
 
923
                                 const char* str, uint length,
926
924
                                 bool allocate_lex_string)
927
925
{
928
926
  if (allocate_lex_string)
956
954
*/
957
955
 
958
956
bool THD::convert_string(LEX_STRING *to, const CHARSET_INFO * const to_cs,
959
 
                         const char *from, uint32_t from_length,
 
957
                         const char *from, uint from_length,
960
958
                         const CHARSET_INFO * const from_cs)
961
959
{
962
960
  size_t new_length= to_cs->mbmaxlen * from_length;
963
 
  uint32_t dummy_errors;
 
961
  uint dummy_errors;
964
962
  if (!(to->str= (char*) alloc(new_length+1)))
965
963
  {
966
964
    to->length= 0;                              // Safety fix
991
989
bool THD::convert_string(String *s, const CHARSET_INFO * const from_cs,
992
990
                         const CHARSET_INFO * const to_cs)
993
991
{
994
 
  uint32_t dummy_errors;
 
992
  uint dummy_errors;
995
993
  if (convert_buffer.copy(s->ptr(), s->length(), from_cs, to_cs, &dummy_errors))
996
994
    return true;
997
995
  /* If convert_buffer >> s copying is more efficient long term */
1162
1160
/*
1163
1161
  Register an item tree tree transformation, performed by the query
1164
1162
  optimizer. We need a pointer to runtime_memroot because it may be !=
1165
 
  thd->mem_root (this may no longer be a true statement)
 
1163
  thd->mem_root (due to possible set_n_backup_active_arena called for thd).
1166
1164
*/
1167
1165
 
1168
1166
void THD::nocheck_register_item_tree_change(Item **place, Item *old_value,
1212
1210
  thd=current_thd;
1213
1211
}
1214
1212
 
1215
 
void select_result::send_error(uint32_t errcode,const char *err)
 
1213
void select_result::send_error(uint errcode,const char *err)
1216
1214
{
1217
1215
  my_message(errcode, err, MYF(0));
1218
1216
}
1246
1244
  cs= NULL;
1247
1245
}
1248
1246
 
1249
 
bool select_send::send_fields(List<Item> &list, uint32_t flags)
 
1247
bool select_send::send_fields(List<Item> &list, uint flags)
1250
1248
{
1251
1249
  bool res;
1252
1250
  if (!(res= thd->protocol->send_fields(&list, flags)))
1340
1338
  Handling writing to file
1341
1339
************************************************************************/
1342
1340
 
1343
 
void select_to_file::send_error(uint32_t errcode,const char *err)
 
1341
void select_to_file::send_error(uint errcode,const char *err)
1344
1342
{
1345
1343
  my_message(errcode, err, MYF(0));
1346
1344
  if (file > 0)
1426
1424
                        IO_CACHE *cache)
1427
1425
{
1428
1426
  File file;
1429
 
  uint32_t option= MY_UNPACK_FILENAME | MY_RELATIVE_PATH;
 
1427
  uint option= MY_UNPACK_FILENAME | MY_RELATIVE_PATH;
1430
1428
 
1431
1429
#ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS
1432
1430
  option|= MY_REPLACE_DIR;                      // Force use of db directory
1435
1433
  if (!dirname_length(exchange->file_name))
1436
1434
  {
1437
1435
    strxnmov(path, FN_REFLEN-1, mysql_real_data_home, thd->db ? thd->db : "",
1438
 
             NULL);
 
1436
             NullS);
1439
1437
    (void) fn_format(path, exchange->file_name, path, "", option);
1440
1438
  }
1441
1439
  else
1502
1500
  }
1503
1501
  field_term_length=exchange->field_term->length();
1504
1502
  field_term_char= field_term_length ?
1505
 
                   (int) (unsigned char) (*exchange->field_term)[0] : INT_MAX;
 
1503
                   (int) (uchar) (*exchange->field_term)[0] : INT_MAX;
1506
1504
  if (!exchange->line_term->length())
1507
1505
    exchange->line_term=exchange->field_term;   // Use this if it exists
1508
1506
  field_sep_char= (exchange->enclosed->length() ?
1509
 
                  (int) (unsigned char) (*exchange->enclosed)[0] : field_term_char);
 
1507
                  (int) (uchar) (*exchange->enclosed)[0] : field_term_char);
1510
1508
  escape_char=  (exchange->escaped->length() ?
1511
 
                (int) (unsigned char) (*exchange->escaped)[0] : -1);
 
1509
                (int) (uchar) (*exchange->escaped)[0] : -1);
1512
1510
  is_ambiguous_field_sep= test(strchr(ESCAPE_CHARS, field_sep_char));
1513
1511
  is_unsafe_field_sep= test(strchr(NUMERIC_CHARS, field_sep_char));
1514
1512
  line_sep_char= (exchange->line_term->length() ?
1515
 
                 (int) (unsigned char) (*exchange->line_term)[0] : INT_MAX);
 
1513
                 (int) (uchar) (*exchange->line_term)[0] : INT_MAX);
1516
1514
  if (!field_term_length)
1517
1515
    exchange->opt_enclosed=0;
1518
1516
  if (!exchange->enclosed->length())
1535
1533
}
1536
1534
 
1537
1535
 
1538
 
#define NEED_ESCAPING(x) ((int) (unsigned char) (x) == escape_char    || \
1539
 
                          (enclosed ? (int) (unsigned char) (x) == field_sep_char      \
1540
 
                                    : (int) (unsigned char) (x) == field_term_char) || \
1541
 
                          (int) (unsigned char) (x) == line_sep_char  || \
 
1536
#define NEED_ESCAPING(x) ((int) (uchar) (x) == escape_char    || \
 
1537
                          (enclosed ? (int) (uchar) (x) == field_sep_char      \
 
1538
                                    : (int) (uchar) (x) == field_term_char) || \
 
1539
                          (int) (uchar) (x) == line_sep_char  || \
1542
1540
                          !(x))
1543
1541
 
1544
1542
bool select_export::send_data(List<Item> &items)
1555
1553
  }
1556
1554
  row_count++;
1557
1555
  Item *item;
1558
 
  uint32_t used_length=0,items_left=items.elements;
 
1556
  uint used_length=0,items_left=items.elements;
1559
1557
  List_iterator_fast<Item> li(items);
1560
1558
 
1561
 
  if (my_b_write(&cache,(unsigned char*) exchange->line_start->ptr(),
 
1559
  if (my_b_write(&cache,(uchar*) exchange->line_start->ptr(),
1562
1560
                 exchange->line_start->length()))
1563
1561
    goto err;
1564
1562
  while ((item=li++))
1569
1567
    res=item->str_result(&tmp);
1570
1568
    if (res && enclosed)
1571
1569
    {
1572
 
      if (my_b_write(&cache,(unsigned char*) exchange->enclosed->ptr(),
 
1570
      if (my_b_write(&cache,(uchar*) exchange->enclosed->ptr(),
1573
1571
                     exchange->enclosed->length()))
1574
1572
        goto err;
1575
1573
    }
1581
1579
        {
1582
1580
          null_buff[0]=escape_char;
1583
1581
          null_buff[1]='N';
1584
 
          if (my_b_write(&cache,(unsigned char*) null_buff,2))
 
1582
          if (my_b_write(&cache,(uchar*) null_buff,2))
1585
1583
            goto err;
1586
1584
        }
1587
 
        else if (my_b_write(&cache,(unsigned char*) "NULL",4))
 
1585
        else if (my_b_write(&cache,(uchar*) "NULL",4))
1588
1586
          goto err;
1589
1587
      }
1590
1588
      else
1595
1593
    else
1596
1594
    {
1597
1595
      if (fixed_row_size)
1598
 
        used_length=cmin(res->length(),item->max_length);
 
1596
        used_length=min(res->length(),item->max_length);
1599
1597
      else
1600
1598
        used_length=res->length();
1601
1599
      if ((result_type == STRING_RESULT || is_unsafe_field_sep) &&
1660
1658
 
1661
1659
          if ((NEED_ESCAPING(*pos) ||
1662
1660
               (check_second_byte &&
1663
 
                my_mbcharlen(character_set_client, (unsigned char) *pos) == 2 &&
 
1661
                my_mbcharlen(character_set_client, (uchar) *pos) == 2 &&
1664
1662
                pos + 1 < end &&
1665
1663
                NEED_ESCAPING(pos[1]))) &&
1666
1664
              /*
1668
1666
               valid for ENCLOSED BY characters:
1669
1667
              */
1670
1668
              (enclosed || !is_ambiguous_field_term ||
1671
 
               (int) (unsigned char) *pos != field_term_char))
 
1669
               (int) (uchar) *pos != field_term_char))
1672
1670
          {
1673
1671
            char tmp_buff[2];
1674
 
            tmp_buff[0]= ((int) (unsigned char) *pos == field_sep_char &&
 
1672
            tmp_buff[0]= ((int) (uchar) *pos == field_sep_char &&
1675
1673
                          is_ambiguous_field_sep) ?
1676
1674
                          field_sep_char : escape_char;
1677
1675
            tmp_buff[1]= *pos ? *pos : '0';
1678
 
            if (my_b_write(&cache,(unsigned char*) start,(uint) (pos-start)) ||
1679
 
                my_b_write(&cache,(unsigned char*) tmp_buff,2))
 
1676
            if (my_b_write(&cache,(uchar*) start,(uint) (pos-start)) ||
 
1677
                my_b_write(&cache,(uchar*) tmp_buff,2))
1680
1678
              goto err;
1681
1679
            start=pos+1;
1682
1680
          }
1683
1681
        }
1684
 
        if (my_b_write(&cache,(unsigned char*) start,(uint) (pos-start)))
 
1682
        if (my_b_write(&cache,(uchar*) start,(uint) (pos-start)))
1685
1683
          goto err;
1686
1684
      }
1687
 
      else if (my_b_write(&cache,(unsigned char*) res->ptr(),used_length))
 
1685
      else if (my_b_write(&cache,(uchar*) res->ptr(),used_length))
1688
1686
        goto err;
1689
1687
    }
1690
1688
    if (fixed_row_size)
1697
1695
          space_inited=1;
1698
1696
          memset(space, ' ', sizeof(space));
1699
1697
        }
1700
 
        uint32_t length=item->max_length-used_length;
 
1698
        uint length=item->max_length-used_length;
1701
1699
        for (; length > sizeof(space) ; length-=sizeof(space))
1702
1700
        {
1703
 
          if (my_b_write(&cache,(unsigned char*) space,sizeof(space)))
 
1701
          if (my_b_write(&cache,(uchar*) space,sizeof(space)))
1704
1702
            goto err;
1705
1703
        }
1706
 
        if (my_b_write(&cache,(unsigned char*) space,length))
 
1704
        if (my_b_write(&cache,(uchar*) space,length))
1707
1705
          goto err;
1708
1706
      }
1709
1707
    }
1710
1708
    if (res && enclosed)
1711
1709
    {
1712
 
      if (my_b_write(&cache, (unsigned char*) exchange->enclosed->ptr(),
 
1710
      if (my_b_write(&cache, (uchar*) exchange->enclosed->ptr(),
1713
1711
                     exchange->enclosed->length()))
1714
1712
        goto err;
1715
1713
    }
1716
1714
    if (--items_left)
1717
1715
    {
1718
 
      if (my_b_write(&cache, (unsigned char*) exchange->field_term->ptr(),
 
1716
      if (my_b_write(&cache, (uchar*) exchange->field_term->ptr(),
1719
1717
                     field_term_length))
1720
1718
        goto err;
1721
1719
    }
1722
1720
  }
1723
 
  if (my_b_write(&cache,(unsigned char*) exchange->line_term->ptr(),
 
1721
  if (my_b_write(&cache,(uchar*) exchange->line_term->ptr(),
1724
1722
                 exchange->line_term->length()))
1725
1723
    goto err;
1726
1724
  return(0);
1766
1764
    res=item->str_result(&tmp);
1767
1765
    if (!res)                                   // If NULL
1768
1766
    {
1769
 
      if (my_b_write(&cache,(unsigned char*) "",1))
 
1767
      if (my_b_write(&cache,(uchar*) "",1))
1770
1768
        goto err;
1771
1769
    }
1772
 
    else if (my_b_write(&cache,(unsigned char*) res->ptr(),res->length()))
 
1770
    else if (my_b_write(&cache,(uchar*) res->ptr(),res->length()))
1773
1771
    {
1774
1772
      my_error(ER_ERROR_ON_WRITE, MYF(0), path, my_errno);
1775
1773
      goto err;
1802
1800
  }
1803
1801
  List_iterator_fast<Item> li(items);
1804
1802
  Item *val_item;
1805
 
  for (uint32_t i= 0; (val_item= li++); i++)
 
1803
  for (uint i= 0; (val_item= li++); i++)
1806
1804
    it->store(i, val_item);
1807
1805
  it->assigned(1);
1808
1806
  return(0);
1978
1976
}
1979
1977
 
1980
1978
 
 
1979
void Query_arena::set_query_arena(Query_arena *set)
 
1980
{
 
1981
  mem_root= set->mem_root;
 
1982
  free_list= set->free_list;
 
1983
  state= set->state;
 
1984
}
 
1985
 
 
1986
 
 
1987
void Query_arena::cleanup_stmt()
 
1988
{
 
1989
  assert("not implemented");
 
1990
}
 
1991
 
1981
1992
/*
1982
1993
  Statement functions
1983
1994
*/
1984
1995
 
1985
 
Statement::Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg, ulong id_arg)
1986
 
  :Query_arena(mem_root_arg),
 
1996
Statement::Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,
 
1997
                     enum enum_state state_arg, ulong id_arg)
 
1998
  :Query_arena(mem_root_arg, state_arg),
1987
1999
  id(id_arg),
1988
2000
  mark_used_columns(MARK_COLUMNS_READ),
1989
2001
  lex(lex_arg),
1992
2004
  db(NULL),
1993
2005
  db_length(0)
1994
2006
{
1995
 
}
1996
 
 
1997
 
 
1998
 
/*
1999
 
  Don't free mem_root, as mem_root is freed in the end of dispatch_command
2000
 
  (once for any command).
2001
 
*/
 
2007
  name.str= NULL;
 
2008
}
 
2009
 
 
2010
 
 
2011
void Statement::set_statement(Statement *stmt)
 
2012
{
 
2013
  id=             stmt->id;
 
2014
  mark_used_columns=   stmt->mark_used_columns;
 
2015
  lex=            stmt->lex;
 
2016
  query=          stmt->query;
 
2017
  query_length=   stmt->query_length;
 
2018
}
 
2019
 
 
2020
 
 
2021
void
 
2022
Statement::set_n_backup_statement(Statement *stmt, Statement *backup)
 
2023
{
 
2024
  backup->set_statement(this);
 
2025
  set_statement(stmt);
 
2026
  return;
 
2027
}
 
2028
 
 
2029
 
 
2030
void Statement::restore_backup_statement(Statement *stmt, Statement *backup)
 
2031
{
 
2032
  stmt->set_statement(this);
 
2033
  set_statement(backup);
 
2034
  return;
 
2035
}
 
2036
 
 
2037
 
2002
2038
void THD::end_statement()
2003
2039
{
2004
2040
  /* Cleanup SQL processing state to reuse this statement in next query. */
2005
2041
  lex_end(lex);
 
2042
  delete lex->result;
 
2043
  lex->result= 0;
 
2044
  /* Note that free_list is freed in cleanup_after_query() */
 
2045
 
 
2046
  /*
 
2047
    Don't free mem_root, as mem_root is freed in the end of dispatch_command
 
2048
    (once for any command).
 
2049
  */
 
2050
}
 
2051
 
 
2052
 
 
2053
void THD::set_n_backup_active_arena(Query_arena *set, Query_arena *backup)
 
2054
{
 
2055
  assert(backup->is_backup_arena == false);
 
2056
 
 
2057
  backup->set_query_arena(this);
 
2058
  set_query_arena(set);
 
2059
  backup->is_backup_arena= true;
 
2060
  return;
 
2061
}
 
2062
 
 
2063
 
 
2064
void THD::restore_active_arena(Query_arena *set, Query_arena *backup)
 
2065
{
 
2066
  assert(backup->is_backup_arena);
 
2067
  set->set_query_arena(this);
 
2068
  set_query_arena(backup);
 
2069
  backup->is_backup_arena= false;
 
2070
  return;
2006
2071
}
2007
2072
 
2008
2073
 
2122
2187
void Security_context::destroy()
2123
2188
{
2124
2189
  // If not pointer to constant
2125
 
  if (user)
2126
 
  {
2127
 
    free(user);
2128
 
    user= NULL;
2129
 
  }
2130
 
  if (ip)
2131
 
  {
2132
 
    free(ip);
2133
 
    ip= NULL;
2134
 
  }
 
2190
  safeFree(user);
 
2191
  safeFree(ip);
2135
2192
}
2136
2193
 
2137
2194
 
2248
2305
pthread_mutex_t LOCK_xid_cache;
2249
2306
HASH xid_cache;
2250
2307
 
2251
 
extern "C" unsigned char *xid_get_hash_key(const unsigned char *, size_t *, bool);
 
2308
extern "C" uchar *xid_get_hash_key(const uchar *, size_t *, bool);
2252
2309
extern "C" void xid_free_hash(void *);
2253
2310
 
2254
 
unsigned char *xid_get_hash_key(const unsigned char *ptr, size_t *length,
 
2311
uchar *xid_get_hash_key(const uchar *ptr, size_t *length,
2255
2312
                        bool not_used __attribute__((unused)))
2256
2313
{
2257
2314
  *length=((XID_STATE*)ptr)->xid.key_length();
2261
2318
void xid_free_hash(void *ptr)
2262
2319
{
2263
2320
  if (!((XID_STATE*)ptr)->in_thd)
2264
 
    free((unsigned char*)ptr);
 
2321
    my_free((uchar*)ptr, MYF(0));
2265
2322
}
2266
2323
 
2267
2324
bool xid_cache_init()
2303
2360
    xs->xa_state=xa_state;
2304
2361
    xs->xid.set(xid);
2305
2362
    xs->in_thd=0;
2306
 
    res=my_hash_insert(&xid_cache, (unsigned char*)xs);
 
2363
    res=my_hash_insert(&xid_cache, (uchar*)xs);
2307
2364
  }
2308
2365
  pthread_mutex_unlock(&LOCK_xid_cache);
2309
2366
  return res;
2315
2372
  pthread_mutex_lock(&LOCK_xid_cache);
2316
2373
  assert(hash_search(&xid_cache, xid_state->xid.key(),
2317
2374
                          xid_state->xid.key_length())==0);
2318
 
  bool res=my_hash_insert(&xid_cache, (unsigned char*)xid_state);
 
2375
  bool res=my_hash_insert(&xid_cache, (uchar*)xid_state);
2319
2376
  pthread_mutex_unlock(&LOCK_xid_cache);
2320
2377
  return res;
2321
2378
}
2324
2381
void xid_cache_delete(XID_STATE *xid_state)
2325
2382
{
2326
2383
  pthread_mutex_lock(&LOCK_xid_cache);
2327
 
  hash_delete(&xid_cache, (unsigned char *)xid_state);
 
2384
  hash_delete(&xid_cache, (uchar *)xid_state);
2328
2385
  pthread_mutex_unlock(&LOCK_xid_cache);
2329
2386
}
2330
2387
 
2334
2391
  inserted/updated/deleted.
2335
2392
*/
2336
2393
 
 
2394
#ifndef DRIZZLE_CLIENT
2337
2395
 
2338
2396
/*
2339
2397
  Template member function for ensuring that there is an rows log
2494
2552
    ~Row_data_memory()
2495
2553
    {
2496
2554
      if (m_memory != 0 && m_release_memory_on_destruction)
2497
 
        free((unsigned char*) m_memory);
 
2555
        my_free((uchar*) m_memory, MYF(MY_WME));
2498
2556
    }
2499
2557
 
2500
2558
    /**
2508
2566
      return m_memory != 0;
2509
2567
    }
2510
2568
 
2511
 
    unsigned char *slot(uint32_t s)
 
2569
    uchar *slot(uint s)
2512
2570
    {
2513
2571
      assert(s < sizeof(m_ptr)/sizeof(*m_ptr));
2514
2572
      assert(m_ptr[s] != 0);
2540
2598
        */
2541
2599
        if (table->write_row_record == 0)
2542
2600
          table->write_row_record=
2543
 
            (unsigned char *) alloc_root(&table->mem_root, 2 * maxlen);
 
2601
            (uchar *) alloc_root(&table->mem_root, 2 * maxlen);
2544
2602
        m_memory= table->write_row_record;
2545
2603
        m_release_memory_on_destruction= false;
2546
2604
      }
2547
2605
      else
2548
2606
      {
2549
 
        m_memory= (unsigned char *) my_malloc(total_length, MYF(MY_WME));
 
2607
        m_memory= (uchar *) my_malloc(total_length, MYF(MY_WME));
2550
2608
        m_release_memory_on_destruction= true;
2551
2609
      }
2552
2610
    }
2553
2611
 
2554
2612
    mutable bool m_alloc_checked;
2555
2613
    bool m_release_memory_on_destruction;
2556
 
    unsigned char *m_memory;
2557
 
    unsigned char *m_ptr[2];
 
2614
    uchar *m_memory;
 
2615
    uchar *m_ptr[2];
2558
2616
  };
2559
2617
}
2560
2618
 
2561
2619
 
2562
2620
int THD::binlog_write_row(Table* table, bool is_trans, 
2563
 
                          unsigned char const *record) 
 
2621
                          uchar const *record) 
2564
2622
{ 
2565
2623
  assert(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2566
2624
 
2572
2630
  if (!memory.has_memory())
2573
2631
    return HA_ERR_OUT_OF_MEM;
2574
2632
 
2575
 
  unsigned char *row_data= memory.slot(0);
 
2633
  uchar *row_data= memory.slot(0);
2576
2634
 
2577
2635
  size_t const len= pack_row(table, table->write_set, row_data, record);
2578
2636
 
2587
2645
}
2588
2646
 
2589
2647
int THD::binlog_update_row(Table* table, bool is_trans,
2590
 
                           const unsigned char *before_record,
2591
 
                           const unsigned char *after_record)
 
2648
                           const uchar *before_record,
 
2649
                           const uchar *after_record)
2592
2650
{ 
2593
2651
  assert(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2594
2652
 
2599
2657
  if (!row_data.has_memory())
2600
2658
    return HA_ERR_OUT_OF_MEM;
2601
2659
 
2602
 
  unsigned char *before_row= row_data.slot(0);
2603
 
  unsigned char *after_row= row_data.slot(1);
 
2660
  uchar *before_row= row_data.slot(0);
 
2661
  uchar *after_row= row_data.slot(1);
2604
2662
 
2605
2663
  size_t const before_size= pack_row(table, table->read_set, before_row,
2606
2664
                                        before_record);
2621
2679
}
2622
2680
 
2623
2681
int THD::binlog_delete_row(Table* table, bool is_trans, 
2624
 
                           unsigned char const *record)
 
2682
                           uchar const *record)
2625
2683
{ 
2626
2684
  assert(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2627
2685
 
2633
2691
  if (unlikely(!memory.has_memory()))
2634
2692
    return HA_ERR_OUT_OF_MEM;
2635
2693
 
2636
 
  unsigned char *row_data= memory.slot(0);
 
2694
  uchar *row_data= memory.slot(0);
2637
2695
 
2638
2696
  size_t const len= pack_row(table, table->read_set, row_data, record);
2639
2697
 
2799
2857
  elements++;
2800
2858
  return(0);
2801
2859
}
 
2860
 
 
2861
#endif /* !defined(DRIZZLE_CLIENT) */