← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.cc

  • Committer: Monty Taylor
  • Date: 2009-03-25 08:39:58 UTC
  • mto: (960.5.2 mordred)
  • mto: This revision was merged to the branch mainline in revision 964.
  • Revision ID: mordred@inaugust.com-20090325083958-5gp7pps4c9id7xol
More naming fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/handler.cc
574
574
    for (; ha_info; ha_info= ha_info->next())
575
575
    {
576
576
      int err;
577
 
      StorageEngine *engine= ha_info->ht();
 
577
      StorageEngine *engine= ha_info->engine();
578
578
      status_var_increment(session->status_var.ha_prepare_count);
579
579
      if ((err= engine->prepare(engine, session, all)))
580
580
      {
624
624
 
625
625
    if (! all)
626
626
    {
627
 
      Ha_trx_info *ha_info_all= &session->ha_data[ha_info->ht()->slot].ha_info[1];
 
627
      Ha_trx_info *ha_info_all= &session->ha_data[ha_info->engine()->slot].ha_info[1];
628
628
      assert(ha_info != ha_info_all);
629
629
      /*
630
630
        Merge read-only/read-write information about statement
701
701
      for (; ha_info && !error; ha_info= ha_info->next())
702
702
      {
703
703
        int err;
704
 
        StorageEngine *engine= ha_info->ht();
 
704
        StorageEngine *engine= ha_info->engine();
705
705
        /*
706
706
          Do not call two-phase commit if this particular
707
707
          transaction is read-only. This allows for simpler
750
750
    for (; ha_info; ha_info= ha_info_next)
751
751
    {
752
752
      int err;
753
 
      StorageEngine *engine= ha_info->ht();
 
753
      StorageEngine *engine= ha_info->engine();
754
754
      if ((err= engine->commit(engine, session, all)))
755
755
      {
756
756
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
793
793
    for (; ha_info; ha_info= ha_info_next)
794
794
    {
795
795
      int err;
796
 
      StorageEngine *engine= ha_info->ht();
 
796
      StorageEngine *engine= ha_info->engine();
797
797
      if ((err= engine->rollback(engine, session, all)))
798
798
      { // cannot happen
799
799
        my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
1148
1148
  for (ha_info= sv->ha_list; ha_info; ha_info= ha_info->next())
1149
1149
  {
1150
1150
    int err;
1151
 
    StorageEngine *engine= ha_info->ht();
 
1151
    StorageEngine *engine= ha_info->engine();
1152
1152
    assert(engine);
1153
1153
    if ((err= engine->savepoint_rollback(engine, session,
1154
1154
                                     (unsigned char *)(sv+1)+engine->savepoint_offset)))
1167
1167
       ha_info= ha_info_next)
1168
1168
  {
1169
1169
    int err;
1170
 
    StorageEngine *engine= ha_info->ht();
 
1170
    StorageEngine *engine= ha_info->engine();
1171
1171
    if ((err= engine->rollback(engine, session, !(0))))
1172
1172
    { // cannot happen
1173
1173
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
1195
1195
  for (; ha_info; ha_info= ha_info->next())
1196
1196
  {
1197
1197
    int err;
1198
 
    StorageEngine *engine= ha_info->ht();
 
1198
    StorageEngine *engine= ha_info->engine();
1199
1199
    assert(engine);
1200
1200
/*    if (! engine->savepoint_set)
1201
1201
    {
1226
1226
  for (; ha_info; ha_info= ha_info->next())
1227
1227
  {
1228
1228
    int err;
1229
 
    StorageEngine *engine= ha_info->ht();
 
1229
    StorageEngine *engine= ha_info->engine();
1230
1230
    /* Savepoint life time is enclosed into transaction life time. */
1231
1231
    assert(engine);
1232
1232
    if ((err= engine->savepoint_release(engine, session,
1568
1568
 
1569
1569
void **handler::ha_data(Session *session) const
1570
1570
{
1571
 
  return session_ha_data(session, ht);
 
1571
  return session_ha_data(session, engine);
1572
1572
}
1573
1573
 
1574
1574
Session *handler::ha_session(void) const
2287
2287
      temporary= get_error_message(error, &str);
2288
2288
      if (!str.is_empty())
2289
2289
      {
2290
 
        const char* engine= table_type();
2291
 
        if (temporary)
2292
 
          my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(), engine);
2293
 
        else
2294
 
          my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine);
 
2290
              const char* engine_name= table_type();
 
2291
              if (temporary)
 
2292
                my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(),
 
2293
                   engine_name);
 
2294
              else
 
2295
                my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine_name);
2295
2296
      }
2296
2297
      else
2297
 
        my_error(ER_GET_ERRNO,errflag,error);
 
2298
      {
 
2299
              my_error(ER_GET_ERRNO,errflag,error);
 
2300
      }
2298
2301
      return;
2299
2302
    }
2300
2303
  }
2471
2474
void
2472
2475
handler::mark_trx_read_write()
2473
2476
{
2474
 
  Ha_trx_info *ha_info= &ha_session()->ha_data[ht->slot].ha_info[0];
 
2477
  Ha_trx_info *ha_info= &ha_session()->ha_data[engine->slot].ha_info[0];
2475
2478
  /*
2476
2479
    When a storage engine method is called, the transaction must
2477
2480
    have been started, unless it's a DDL call, for which the