common/transaction/basics/driver.cxx


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

// file      : common/transaction/basics/driver.cxx
// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC
// license   : GNU GPL v2; see accompanying LICENSE file

// Test basic transaction operations.
//

#include <string>
#include <cassert>
#include <iostream>

#include <odb/tracer.hxx>
#include <odb/database.hxx>
#include <odb/transaction.hxx>
#include <odb/statement.hxx>
#include <odb/exceptions.hxx>

#include <common/common.hxx>
#include <common/concrete.hxx>

using namespace std;
using namespace odb::core;

struct transaction_tracer: odb::tracer
{
  virtual void
  execute (connection&, const char* s)
  {
    string str (s);

    if (str == "BEGIN")
      cout << "begin transaction" << endl;
    else if (str == "COMMIT")
      cout << "commit transaction" << endl;
    else if (str == "ROLLBACK")
      cout << "rollback transaction" << endl;
  }

  // Override the other version to get rid of a Sun CC warning.
  //
  virtual void
  execute (connection& c, const statement& s)
  {
    execute (c, s.text ());
  }
};

int
main (int argc, char* argv[])
{
  {
    transaction_tracer tracer;
    auto_ptr<database> db (create_database (argc, argv, false));
    db->tracer (tracer);

    assert (!transaction::has_current ());

    // Current and db accessors.
    //
    cout << "test 001" << endl;
    {
      transaction t (db->begin ());
      assert (&t.database () == db.get ());
      assert (transaction::has_current ());
      assert (&transaction::current () == &t);

      transaction::reset_current ();
      assert (!transaction::has_current ());

      transaction t2 (db->begin (), false);
      assert (!transaction::has_current ());

      transaction::current (t2);
      assert (&transaction::current () == &t2);
    }

    // Commit.
    //
    cout << "test 002" << endl;
    {
      transaction t (db->begin ());
      t.commit ();
    }

    // Rollback.
    //
    cout << "test 003" << endl;
    {
      transaction t (db->begin ());
      t.rollback ();
    }

    // Auto rollback.
    //
    cout << "test 004" << endl;
    {
      transaction t (db->begin ());
    }

    // Nested transaction.
    //
    cout << "test 005" << endl;
    {
      transaction t (db->begin ());

      try
      {
        transaction n (db->begin ());
      }
      catch (const already_in_transaction&)
      {
        cout << "already_in_transaction" << endl;
      }
    }

    // Concrete transaction type.
    //
    cout << "test 006" << endl;
    {
      assert (sizeof (odb_db::transaction) == sizeof (transaction));

      odb_db::transaction t (static_cast<odb_db::database&> (*db).begin ());
      odb_db::transaction& r (odb_db::transaction::current ());
      assert (&t == &r);
    }

    // Transaction restart.
    //
    cout << "test 007" << endl;
    {
      transaction t (db->begin ());
      t.commit ();
      t.reset (db->begin ());
      t.commit ();
    }
  }

  // Test early connection release.
  //
  {
    auto_ptr<database> db (create_database (argc, argv, false, 1));
    transaction t1 (db->begin ());
    t1.commit ();
    transaction t2 (db->begin ());
    t2.rollback ();
    transaction t3 (db->begin ());
    t3.commit ();
  }
}