← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_class.cc

  • Committer: Brian Aker
  • Date: 2008-10-20 04:28:21 UTC
  • mto: (492.3.21 drizzle-clean-code)
  • mto: This revision was merged to the branch mainline in revision 530.
  • Revision ID: brian@tangent.org-20081020042821-rqqdrccuu8195k3y
Second pass of thd cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_class.cc
265
265
 
266
266
 
267
267
extern "C"
268
 
int thd_in_lock_tables(const Session *thd)
 
268
int session_in_lock_tables(const Session *session)
269
269
{
270
 
  return test(thd->in_lock_tables);
 
270
  return test(session->in_lock_tables);
271
271
}
272
272
 
273
273
 
274
274
extern "C"
275
 
int thd_tablespace_op(const Session *thd)
 
275
int session_tablespace_op(const Session *session)
276
276
{
277
 
  return test(thd->tablespace_op);
 
277
  return test(session->tablespace_op);
278
278
}
279
279
 
280
280
 
287
287
   @see Session::set_proc_info
288
288
 */
289
289
extern "C" void
290
 
set_thd_proc_info(Session *thd, const char *info)
291
 
{
292
 
  thd->set_proc_info(info);
293
 
}
294
 
 
295
 
extern "C"
296
 
const char *get_thd_proc_info(Session *thd)
297
 
{
298
 
  return thd->get_proc_info();
299
 
}
300
 
 
301
 
extern "C"
302
 
void **thd_ha_data(const Session *thd, const struct handlerton *hton)
303
 
{
304
 
  return (void **) &thd->ha_data[hton->slot].ha_ptr;
305
 
}
306
 
 
307
 
extern "C"
308
 
int64_t thd_test_options(const Session *thd, int64_t test_options)
309
 
{
310
 
  return thd->options & test_options;
311
 
}
312
 
 
313
 
extern "C"
314
 
int thd_sql_command(const Session *thd)
315
 
{
316
 
  return (int) thd->lex->sql_command;
317
 
}
318
 
 
319
 
extern "C"
320
 
int thd_tx_isolation(const Session *thd)
321
 
{
322
 
  return (int) thd->variables.tx_isolation;
323
 
}
324
 
 
325
 
extern "C"
326
 
void thd_inc_row_count(Session *thd)
327
 
{
328
 
  thd->row_count++;
 
290
set_session_proc_info(Session *session, const char *info)
 
291
{
 
292
  session->set_proc_info(info);
 
293
}
 
294
 
 
295
extern "C"
 
296
const char *get_session_proc_info(Session *session)
 
297
{
 
298
  return session->get_proc_info();
 
299
}
 
300
 
 
301
extern "C"
 
302
void **session_ha_data(const Session *session, const struct handlerton *hton)
 
303
{
 
304
  return (void **) &session->ha_data[hton->slot].ha_ptr;
 
305
}
 
306
 
 
307
extern "C"
 
308
int64_t session_test_options(const Session *session, int64_t test_options)
 
309
{
 
310
  return session->options & test_options;
 
311
}
 
312
 
 
313
extern "C"
 
314
int session_sql_command(const Session *session)
 
315
{
 
316
  return (int) session->lex->sql_command;
 
317
}
 
318
 
 
319
extern "C"
 
320
int session_tx_isolation(const Session *session)
 
321
{
 
322
  return (int) session->variables.tx_isolation;
 
323
}
 
324
 
 
325
extern "C"
 
326
void session_inc_row_count(Session *session)
 
327
{
 
328
  session->row_count++;
329
329
}
330
330
 
331
331
/**
357
357
*/
358
358
 
359
359
void
360
 
Diagnostics_area::set_ok_status(Session *thd, ha_rows affected_rows_arg,
 
360
Diagnostics_area::set_ok_status(Session *session, ha_rows affected_rows_arg,
361
361
                                uint64_t last_insert_id_arg,
362
362
                                const char *message_arg)
363
363
{
370
370
    return;
371
371
  /** Only allowed to report success if has not yet reported an error */
372
372
 
373
 
  m_server_status= thd->server_status;
374
 
  m_total_warn_count= thd->total_warn_count;
 
373
  m_server_status= session->server_status;
 
374
  m_total_warn_count= session->total_warn_count;
375
375
  m_affected_rows= affected_rows_arg;
376
376
  m_last_insert_id= last_insert_id_arg;
377
377
  if (message_arg)
387
387
*/
388
388
 
389
389
void
390
 
Diagnostics_area::set_eof_status(Session *thd)
 
390
Diagnostics_area::set_eof_status(Session *session)
391
391
{
392
392
  /** Only allowed to report eof if has not yet reported an error */
393
393
 
399
399
  if (is_error() || is_disabled())
400
400
    return;
401
401
 
402
 
  m_server_status= thd->server_status;
 
402
  m_server_status= session->server_status;
403
403
  /*
404
404
    If inside a stored procedure, do not return the total
405
405
    number of warnings, since they are not available to the client
406
406
    anyway.
407
407
  */
408
 
  m_total_warn_count= thd->total_warn_count;
 
408
  m_total_warn_count= session->total_warn_count;
409
409
 
410
410
  m_status= DA_EOF;
411
411
}
415
415
*/
416
416
 
417
417
void
418
 
Diagnostics_area::set_error_status(Session *thd __attribute__((unused)),
 
418
Diagnostics_area::set_error_status(Session *session __attribute__((unused)),
419
419
                                   uint32_t sql_errno_arg,
420
420
                                   const char *message_arg)
421
421
{
597
597
}
598
598
 
599
599
extern "C"
600
 
void *thd_alloc(Session *thd, unsigned int size)
601
 
{
602
 
  return thd->alloc(size);
603
 
}
604
 
 
605
 
extern "C"
606
 
void *thd_calloc(Session *thd, unsigned int size)
607
 
{
608
 
  return thd->calloc(size);
609
 
}
610
 
 
611
 
extern "C"
612
 
char *thd_strdup(Session *thd, const char *str)
613
 
{
614
 
  return thd->strdup(str);
615
 
}
616
 
 
617
 
extern "C"
618
 
char *thd_strmake(Session *thd, const char *str, unsigned int size)
619
 
{
620
 
  return thd->strmake(str, size);
621
 
}
622
 
 
623
 
extern "C"
624
 
LEX_STRING *thd_make_lex_string(Session *thd, LEX_STRING *lex_str,
 
600
void *session_alloc(Session *session, unsigned int size)
 
601
{
 
602
  return session->alloc(size);
 
603
}
 
604
 
 
605
extern "C"
 
606
void *session_calloc(Session *session, unsigned int size)
 
607
{
 
608
  return session->calloc(size);
 
609
}
 
610
 
 
611
extern "C"
 
612
char *session_strdup(Session *session, const char *str)
 
613
{
 
614
  return session->strdup(str);
 
615
}
 
616
 
 
617
extern "C"
 
618
char *session_strmake(Session *session, const char *str, unsigned int size)
 
619
{
 
620
  return session->strmake(str, size);
 
621
}
 
622
 
 
623
extern "C"
 
624
LEX_STRING *session_make_lex_string(Session *session, LEX_STRING *lex_str,
625
625
                                const char *str, unsigned int size,
626
626
                                int allocate_lex_string)
627
627
{
628
 
  return thd->make_lex_string(lex_str, str, size,
 
628
  return session->make_lex_string(lex_str, str, size,
629
629
                              (bool) allocate_lex_string);
630
630
}
631
631
 
632
632
extern "C"
633
 
void *thd_memdup(Session *thd, const void* str, unsigned int size)
 
633
void *session_memdup(Session *session, const void* str, unsigned int size)
634
634
{
635
 
  return thd->memdup(str, size);
 
635
  return session->memdup(str, size);
636
636
}
637
637
 
638
638
extern "C"
639
 
void thd_get_xid(const Session *thd, DRIZZLE_XID *xid)
 
639
void session_get_xid(const Session *session, DRIZZLE_XID *xid)
640
640
{
641
 
  *xid = *(DRIZZLE_XID *) &thd->transaction.xid_state.xid;
 
641
  *xid = *(DRIZZLE_XID *) &session->transaction.xid_state.xid;
642
642
}
643
643
 
644
644
/*
648
648
void Session::init(void)
649
649
{
650
650
  pthread_mutex_lock(&LOCK_global_system_variables);
651
 
  plugin_thdvar_init(this);
 
651
  plugin_sessionvar_init(this);
652
652
  variables.time_format= date_time_format_copy((Session*) 0,
653
653
                                               variables.time_format);
654
654
  variables.date_format= date_time_format_copy((Session*) 0,
663
663
  variables.pseudo_thread_id= thread_id;
664
664
  pthread_mutex_unlock(&LOCK_global_system_variables);
665
665
  server_status= SERVER_STATUS_AUTOCOMMIT;
666
 
  options= thd_startup_options;
 
666
  options= session_startup_options;
667
667
 
668
668
  if (variables.max_join_size == HA_POS_ERROR)
669
669
    options |= OPTION_BIG_SELECTS;
702
702
                      variables.trans_alloc_block_size,
703
703
                      variables.trans_prealloc_size);
704
704
  transaction.xid_state.xid.null();
705
 
  transaction.xid_state.in_thd=1;
 
705
  transaction.xid_state.in_session=1;
706
706
}
707
707
 
708
708
 
761
761
    cleanup();
762
762
 
763
763
  ha_close_connection(this);
764
 
  plugin_thdvar_cleanup(this);
 
764
  plugin_sessionvar_cleanup(this);
765
765
 
766
766
  main_security_ctx.destroy();
767
767
  if (db)
869
869
      current_cond and current_mutex are 0), then the victim will not get
870
870
      a signal and it may wait "forever" on the cond (until
871
871
      we issue a second KILL or the status it's waiting for happens).
872
 
      It's true that we have set its thd->killed but it may not
 
872
      It's true that we have set its session->killed but it may not
873
873
      see it immediately and so may have time to reach the cond_wait().
874
874
    */
875
875
    if (mysys_var->current_cond && mysys_var->current_mutex)
1211
1211
/*
1212
1212
  Register an item tree tree transformation, performed by the query
1213
1213
  optimizer. We need a pointer to runtime_memroot because it may be !=
1214
 
  thd->mem_root (this may no longer be a true statement)
 
1214
  session->mem_root (this may no longer be a true statement)
1215
1215
*/
1216
1216
 
1217
1217
void Session::nocheck_register_item_tree_change(Item **place, Item *old_value,
1227
1227
  if (change_mem == 0)
1228
1228
  {
1229
1229
    /*
1230
 
      OOM, thd->fatal_error() is called by the error handler of the
 
1230
      OOM, session->fatal_error() is called by the error handler of the
1231
1231
      memroot. Just return.
1232
1232
    */
1233
1233
    return;
1258
1258
 
1259
1259
select_result::select_result()
1260
1260
{
1261
 
  thd=current_thd;
 
1261
  session=current_session;
1262
1262
}
1263
1263
 
1264
1264
void select_result::send_error(uint32_t errcode,const char *err)
1298
1298
bool select_send::send_fields(List<Item> &list, uint32_t flags)
1299
1299
{
1300
1300
  bool res;
1301
 
  if (!(res= thd->protocol->send_fields(&list, flags)))
 
1301
  if (!(res= session->protocol->send_fields(&list, flags)))
1302
1302
    is_result_set_started= 1;
1303
1303
  return res;
1304
1304
}
1333
1333
  /*
1334
1334
    We may be passing the control from mysqld to the client: release the
1335
1335
    InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
1336
 
    by thd
 
1336
    by session
1337
1337
  */
1338
 
  ha_release_temporary_latches(thd);
 
1338
  ha_release_temporary_latches(session);
1339
1339
 
1340
1340
  List_iterator_fast<Item> li(items);
1341
 
  Protocol *protocol= thd->protocol;
 
1341
  Protocol *protocol= session->protocol;
1342
1342
  char buff[MAX_FIELD_WIDTH];
1343
1343
  String buffer(buff, sizeof(buff), &my_charset_bin);
1344
1344
 
1353
1353
      break;
1354
1354
    }
1355
1355
  }
1356
 
  thd->sent_row_count++;
1357
 
  if (thd->is_error())
 
1356
  session->sent_row_count++;
 
1357
  if (session->is_error())
1358
1358
  {
1359
1359
    protocol->remove_last_row();
1360
1360
    return(1);
1361
1361
  }
1362
 
  if (thd->vio_ok())
 
1362
  if (session->vio_ok())
1363
1363
    return(protocol->write());
1364
1364
  return(0);
1365
1365
}
1369
1369
  /* 
1370
1370
    We may be passing the control from mysqld to the client: release the
1371
1371
    InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
1372
 
    by thd 
 
1372
    by session 
1373
1373
  */
1374
 
  ha_release_temporary_latches(thd);
 
1374
  ha_release_temporary_latches(session);
1375
1375
 
1376
1376
  /* Unlock tables before sending packet to gain some speed */
1377
 
  if (thd->lock)
 
1377
  if (session->lock)
1378
1378
  {
1379
 
    mysql_unlock_tables(thd, thd->lock);
1380
 
    thd->lock=0;
 
1379
    mysql_unlock_tables(session, session->lock);
 
1380
    session->lock=0;
1381
1381
  }
1382
 
  ::my_eof(thd);
 
1382
  ::my_eof(session);
1383
1383
  is_result_set_started= 0;
1384
1384
  return false;
1385
1385
}
1414
1414
      function, SELECT INTO has to have an own SQLCOM.
1415
1415
      TODO: split from SQLCOM_SELECT
1416
1416
    */
1417
 
    ::my_ok(thd,row_count);
 
1417
    ::my_ok(session,row_count);
1418
1418
  }
1419
1419
  file= -1;
1420
1420
  return error;
1451
1451
 
1452
1452
select_export::~select_export()
1453
1453
{
1454
 
  thd->sent_row_count=row_count;
 
1454
  session->sent_row_count=row_count;
1455
1455
}
1456
1456
 
1457
1457
 
1460
1460
 
1461
1461
  SYNOPSIS
1462
1462
    create_file()
1463
 
    thd                 Thread handle
 
1463
    session                     Thread handle
1464
1464
    path                File name
1465
1465
    exchange            Excange class
1466
1466
    cache               IO cache
1471
1471
*/
1472
1472
 
1473
1473
 
1474
 
static File create_file(Session *thd, char *path, sql_exchange *exchange,
 
1474
static File create_file(Session *session, char *path, sql_exchange *exchange,
1475
1475
                        IO_CACHE *cache)
1476
1476
{
1477
1477
  File file;
1483
1483
 
1484
1484
  if (!dirname_length(exchange->file_name))
1485
1485
  {
1486
 
    strxnmov(path, FN_REFLEN-1, mysql_real_data_home, thd->db ? thd->db : "",
 
1486
    strxnmov(path, FN_REFLEN-1, mysql_real_data_home, session->db ? session->db : "",
1487
1487
             NULL);
1488
1488
    (void) fn_format(path, exchange->file_name, path, "", option);
1489
1489
  }
1530
1530
  if ((uint) strlen(exchange->file_name) + NAME_LEN >= FN_REFLEN)
1531
1531
    strmake(path,exchange->file_name,FN_REFLEN-1);
1532
1532
 
1533
 
  if ((file= create_file(thd, path, exchange, &cache)) < 0)
 
1533
  if ((file= create_file(session, path, exchange, &cache)) < 0)
1534
1534
    return 1;
1535
1535
  /* Check if there is any blobs in data */
1536
1536
  {
1573
1573
      (exchange->opt_enclosed && non_string_results &&
1574
1574
       field_term_length && strchr(NUMERIC_CHARS, field_term_char)))
1575
1575
  {
1576
 
    push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
1576
    push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
1577
1577
                 ER_AMBIGUOUS_FIELD_TERM, ER(ER_AMBIGUOUS_FIELD_TERM));
1578
1578
    is_ambiguous_field_term= true;
1579
1579
  }
1652
1652
      {
1653
1653
        char *pos, *start, *end;
1654
1654
        const CHARSET_INFO * const res_charset= res->charset();
1655
 
        const CHARSET_INFO * const character_set_client= thd->variables.
 
1655
        const CHARSET_INFO * const character_set_client= session->variables.
1656
1656
                                                            character_set_client;
1657
1657
        bool check_second_byte= (res_charset == &my_charset_bin) &&
1658
1658
                                 character_set_client->
1788
1788
                     SELECT_LEX_UNIT *u)
1789
1789
{
1790
1790
  unit= u;
1791
 
  return (int) ((file= create_file(thd, path, exchange, &cache)) < 0);
 
1791
  return (int) ((file= create_file(session, path, exchange, &cache)) < 0);
1792
1792
}
1793
1793
 
1794
1794
 
2090
2090
    if (mv->local == 0)
2091
2091
    {
2092
2092
      Item_func_set_user_var *suv= new Item_func_set_user_var(mv->s, item);
2093
 
      suv->fix_fields(thd, 0);
 
2093
      suv->fix_fields(session, 0);
2094
2094
      suv->check(0);
2095
2095
      suv->update();
2096
2096
    }
2097
2097
  }
2098
 
  return(thd->is_error());
 
2098
  return(session->is_error());
2099
2099
}
2100
2100
 
2101
2101
bool select_dumpvar::send_eof()
2102
2102
{
2103
2103
  if (! row_count)
2104
 
    push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
2104
    push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
2105
2105
                 ER_SP_FETCH_NO_DATA, ER(ER_SP_FETCH_NO_DATA));
2106
2106
  /*
2107
2107
    In order to remember the value of affected rows for ROW_COUNT()
2108
2108
    function, SELECT INTO has to have an own SQLCOM.
2109
2109
    TODO: split from SQLCOM_SELECT
2110
2110
  */
2111
 
  ::my_ok(thd,row_count);
 
2111
  ::my_ok(session,row_count);
2112
2112
  return 0;
2113
2113
}
2114
2114
 
2128
2128
}
2129
2129
 
2130
2130
 
2131
 
void thd_increment_bytes_sent(ulong length)
 
2131
void session_increment_bytes_sent(ulong length)
2132
2132
{
2133
 
  Session *thd=current_thd;
2134
 
  if (likely(thd != 0))
2135
 
  { /* current_thd==0 when close_connection() calls net_send_error() */
2136
 
    thd->status_var.bytes_sent+= length;
 
2133
  Session *session=current_session;
 
2134
  if (likely(session != 0))
 
2135
  { /* current_session==0 when close_connection() calls net_send_error() */
 
2136
    session->status_var.bytes_sent+= length;
2137
2137
  }
2138
2138
}
2139
2139
 
2140
2140
 
2141
 
void thd_increment_bytes_received(ulong length)
 
2141
void session_increment_bytes_received(ulong length)
2142
2142
{
2143
 
  current_thd->status_var.bytes_received+= length;
 
2143
  current_session->status_var.bytes_received+= length;
2144
2144
}
2145
2145
 
2146
2146
 
2147
 
void thd_increment_net_big_packet_count(ulong length)
 
2147
void session_increment_net_big_packet_count(ulong length)
2148
2148
{
2149
 
  current_thd->status_var.net_big_packet_count+= length;
 
2149
  current_session->status_var.net_big_packet_count+= length;
2150
2150
}
2151
2151
 
2152
2152
void Session::send_kill_message() const
2222
2222
 
2223
2223
/**
2224
2224
  Check the killed state of a user thread
2225
 
  @param thd  user thread
 
2225
  @param session  user thread
2226
2226
  @retval 0 the user thread is active
2227
2227
  @retval 1 the user thread has been killed
2228
2228
*/
2229
 
extern "C" int thd_killed(const Session *thd)
 
2229
extern "C" int session_killed(const Session *session)
2230
2230
{
2231
 
  return(thd->killed);
 
2231
  return(session->killed);
2232
2232
}
2233
2233
 
2234
2234
/**
2235
2235
  Return the thread id of a user thread
2236
 
  @param thd user thread
 
2236
  @param session user thread
2237
2237
  @return thread id
2238
2238
*/
2239
 
extern "C" unsigned long thd_get_thread_id(const Session *thd)
 
2239
extern "C" unsigned long session_get_thread_id(const Session *session)
2240
2240
{
2241
 
  return((unsigned long)thd->thread_id);
 
2241
  return((unsigned long)session->thread_id);
2242
2242
}
2243
2243
 
2244
2244
 
2245
2245
#ifdef INNODB_COMPATIBILITY_HOOKS
2246
 
extern "C" const struct charset_info_st *thd_charset(Session *thd)
2247
 
{
2248
 
  return(thd->charset());
2249
 
}
2250
 
 
2251
 
extern "C" char **thd_query(Session *thd)
2252
 
{
2253
 
  return(&thd->query);
2254
 
}
2255
 
 
2256
 
extern "C" int thd_slave_thread(const Session *thd)
2257
 
{
2258
 
  return(thd->slave_thread);
2259
 
}
2260
 
 
2261
 
extern "C" int thd_non_transactional_update(const Session *thd)
2262
 
{
2263
 
  return(thd->transaction.all.modified_non_trans_table);
2264
 
}
2265
 
 
2266
 
extern "C" int thd_binlog_format(const Session *thd)
2267
 
{
2268
 
  return (int) thd->variables.binlog_format;
2269
 
}
2270
 
 
2271
 
extern "C" void thd_mark_transaction_to_rollback(Session *thd, bool all)
2272
 
{
2273
 
  mark_transaction_to_rollback(thd, all);
 
2246
extern "C" const struct charset_info_st *session_charset(Session *session)
 
2247
{
 
2248
  return(session->charset());
 
2249
}
 
2250
 
 
2251
extern "C" char **session_query(Session *session)
 
2252
{
 
2253
  return(&session->query);
 
2254
}
 
2255
 
 
2256
extern "C" int session_slave_thread(const Session *session)
 
2257
{
 
2258
  return(session->slave_thread);
 
2259
}
 
2260
 
 
2261
extern "C" int session_non_transactional_update(const Session *session)
 
2262
{
 
2263
  return(session->transaction.all.modified_non_trans_table);
 
2264
}
 
2265
 
 
2266
extern "C" int session_binlog_format(const Session *session)
 
2267
{
 
2268
  return (int) session->variables.binlog_format;
 
2269
}
 
2270
 
 
2271
extern "C" void session_mark_transaction_to_rollback(Session *session, bool all)
 
2272
{
 
2273
  mark_transaction_to_rollback(session, all);
2274
2274
}
2275
2275
#endif // INNODB_COMPATIBILITY_HOOKS */
2276
2276
 
2278
2278
/**
2279
2279
  Mark transaction to rollback and mark error as fatal to a sub-statement.
2280
2280
 
2281
 
  @param  thd   Thread handle
 
2281
  @param  session   Thread handle
2282
2282
  @param  all   true <=> rollback main transaction.
2283
2283
*/
2284
2284
 
2285
 
void mark_transaction_to_rollback(Session *thd, bool all)
 
2285
void mark_transaction_to_rollback(Session *session, bool all)
2286
2286
{
2287
 
  if (thd)
 
2287
  if (session)
2288
2288
  {
2289
 
    thd->is_fatal_sub_stmt_error= true;
2290
 
    thd->transaction_rollback_request= all;
 
2289
    session->is_fatal_sub_stmt_error= true;
 
2290
    session->transaction_rollback_request= all;
2291
2291
  }
2292
2292
}
2293
2293
/***************************************************************************
2309
2309
 
2310
2310
void xid_free_hash(void *ptr)
2311
2311
{
2312
 
  if (!((XID_STATE*)ptr)->in_thd)
 
2312
  if (!((XID_STATE*)ptr)->in_session)
2313
2313
    free((unsigned char*)ptr);
2314
2314
}
2315
2315
 
2351
2351
  {
2352
2352
    xs->xa_state=xa_state;
2353
2353
    xs->xid.set(xid);
2354
 
    xs->in_thd=0;
 
2354
    xs->in_session=0;
2355
2355
    res=my_hash_insert(&xid_cache, (unsigned char*)xs);
2356
2356
  }
2357
2357
  pthread_mutex_unlock(&LOCK_xid_cache);
2392
2392
    - Events of type 'RowEventT' have the type code 'type_code'.
2393
2393
    
2394
2394
  POST CONDITION:
2395
 
    If a non-NULL pointer is returned, the pending event for thread 'thd' will
 
2395
    If a non-NULL pointer is returned, the pending event for thread 'session' will
2396
2396
    be an event of type 'RowEventT' (which have the type code 'type_code')
2397
2397
    will either empty or have enough space to hold 'needed' bytes.  In
2398
2398
    addition, the columns bitmap will be correct for the row, meaning that