← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.cc

  • Committer: Brian Aker
  • Date: 2009-10-02 19:38:12 UTC
  • mfrom: (1152.1.7 merge)
  • Revision ID: brian@gaz-20091002193812-mpd61oecep74t6gd
Merge Monty + Brian for plugins.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/handler.cc
44
44
using namespace std;
45
45
using namespace drizzled;
46
46
 
47
 
extern drizzled::ReplicationServices replication_services;
48
 
 
49
47
KEY_CREATE_INFO default_key_create_info= { HA_KEY_ALG_UNDEF, 0, {NULL,0} };
50
48
 
51
49
/* number of entries in storage_engines[] */
365
363
  in each engine independently. The two-phase commit protocol
366
364
  is used only if:
367
365
  - all participating engines support two-phase commit (provide
368
 
    StorageEngine::prepare PSEA API call) and
 
366
    plugin::StorageEngine::prepare PSEA API call) and
369
367
  - transactions in at least two engines modify data (i.e. are
370
368
  not read-only).
371
369
 
429
427
 
430
428
  At the end of a statement, server call
431
429
  ha_autocommit_or_rollback() is invoked. This call in turn
432
 
  invokes StorageEngine::prepare() for every involved engine.
433
 
  Prepare is followed by a call to StorageEngine::commit_one_phase()
434
 
  If a one-phase commit will suffice, StorageEngine::prepare() is not
435
 
  invoked and the server only calls StorageEngine::commit_one_phase().
 
430
  invokes plugin::StorageEngine::prepare() for every involved engine.
 
431
  Prepare is followed by a call to plugin::StorageEngine::commit_one_phase()
 
432
  If a one-phase commit will suffice, plugin::StorageEngine::prepare() is not
 
433
  invoked and the server only calls plugin::StorageEngine::commit_one_phase().
436
434
  At statement commit, the statement-related read-write engine
437
435
  flag is propagated to the corresponding flag in the normal
438
436
  transaction.  When the commit is complete, the list of registered
491
489
    times per transaction.
492
490
 
493
491
*/
494
 
void trans_register_ha(Session *session, bool all, StorageEngine *engine)
 
492
void trans_register_ha(Session *session, bool all, plugin::StorageEngine *engine)
495
493
{
496
494
  Session_TRANS *trans;
497
495
  Ha_trx_info *ha_info;
623
621
      for (; ha_info && !error; ha_info= ha_info->next())
624
622
      {
625
623
        int err;
626
 
        StorageEngine *engine= ha_info->engine();
 
624
        plugin::StorageEngine *engine= ha_info->engine();
627
625
        /*
628
626
          Do not call two-phase commit if this particular
629
627
          transaction is read-only. This allows for simpler
672
670
    for (; ha_info; ha_info= ha_info_next)
673
671
    {
674
672
      int err;
675
 
      StorageEngine *engine= ha_info->engine();
 
673
      plugin::StorageEngine *engine= ha_info->engine();
676
674
      if ((err= engine->commit(session, all)))
677
675
      {
678
676
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
715
713
    for (; ha_info; ha_info= ha_info_next)
716
714
    {
717
715
      int err;
718
 
      StorageEngine *engine= ha_info->engine();
 
716
      plugin::StorageEngine *engine= ha_info->engine();
719
717
      if ((err= engine->rollback(session, all)))
720
718
      { // cannot happen
721
719
        my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
847
845
  for (ha_info= sv->ha_list; ha_info; ha_info= ha_info->next())
848
846
  {
849
847
    int err;
850
 
    StorageEngine *engine= ha_info->engine();
 
848
    plugin::StorageEngine *engine= ha_info->engine();
851
849
    assert(engine);
852
850
    if ((err= engine->savepoint_rollback(session,
853
851
                                         (void *)(sv+1))))
866
864
       ha_info= ha_info_next)
867
865
  {
868
866
    int err;
869
 
    StorageEngine *engine= ha_info->engine();
 
867
    plugin::StorageEngine *engine= ha_info->engine();
870
868
    if ((err= engine->rollback(session, !(0))))
871
869
    { // cannot happen
872
870
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
894
892
  for (; ha_info; ha_info= ha_info->next())
895
893
  {
896
894
    int err;
897
 
    StorageEngine *engine= ha_info->engine();
 
895
    plugin::StorageEngine *engine= ha_info->engine();
898
896
    assert(engine);
899
897
#ifdef NOT_IMPLEMENTED /*- TODO (examine this againt the original code base) */
900
898
    if (! engine->savepoint_set)
927
925
  for (; ha_info; ha_info= ha_info->next())
928
926
  {
929
927
    int err;
930
 
    StorageEngine *engine= ha_info->engine();
 
928
    plugin::StorageEngine *engine= ha_info->engine();
931
929
    /* Savepoint life time is enclosed into transaction life time. */
932
930
    assert(engine);
933
931
    if ((err= engine->savepoint_release(session,
2614
2612
  return false;
2615
2613
}
2616
2614
 
2617
 
bool ha_show_status(Session *session, StorageEngine *engine, enum ha_stat_type stat)
 
2615
bool ha_show_status(Session *session, plugin::StorageEngine *engine, enum ha_stat_type stat)
2618
2616
{
2619
2617
  List<Item> field_list;
2620
2618
  bool result;
2650
2648
                           const unsigned char *before_record,
2651
2649
                           const unsigned char *after_record)
2652
2650
{
 
2651
  ReplicationServices &replication_services= ReplicationServices::singleton();
2653
2652
  Session *const session= table->in_use;
2654
2653
 
2655
2654
  switch (session->lex->sql_command)