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
|
/** Definition of the pqxx::nontransaction class.
*
* pqxx::nontransaction provides nontransactional database access
*
* DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/nontransaction instead.
*
* Copyright (c) 2000-2019, Jeroen T. Vermeulen.
*
* See COPYING for copyright license. If you did not receive a file called
* COPYING with this source code, please notify the distributor of this mistake,
* or contact the author.
*/
#ifndef PQXX_H_NONTRANSACTION
#define PQXX_H_NONTRANSACTION
#include "pqxx/compiler-public.hxx"
#include "pqxx/compiler-internal-pre.hxx"
#include "pqxx/connection_base.hxx"
#include "pqxx/result.hxx"
#include "pqxx/transaction_base.hxx"
// Methods tested in eg. test module test01 are marked with "//[t01]".
namespace pqxx
{
/// Simple "transaction" class offering no transactional integrity.
/**
* @ingroup transaction
*
* nontransaction, like transaction or any other transaction_base-derived class,
* provides access to a database through a connection. Unlike its siblings,
* however, nontransaction does not maintain any kind of transactional
* integrity. This may be useful eg. for read-only access to the database that
* does not require a consistent, atomic view on its data; or for operations
* that are not allowed within a backend transaction, such as creating tables.
*
* For queries that update the database, however, a real transaction is likely
* to be faster unless the transaction consists of only a single record update.
*
* Also, you can keep a nontransaction open for as long as you like. Actual
* back-end transactions are limited in lifespan, and will sometimes fail just
* because they took too long to execute or were left idle for too long. This
* will not happen with a nontransaction (although the connection may still time
* out, e.g. when the network is unavailable for a very long time).
*
* Any query executed in a nontransaction is committed immediately, and neither
* commit() nor abort() has any effect.
*
* Database features that require a backend transaction, such as cursors or
* large objects, will not work in a nontransaction.
*/
class PQXX_LIBEXPORT nontransaction : public transaction_base
{
public:
/// Constructor.
/** Create a "dummy" transaction.
* @param C Connection that this "transaction" will operate on.
* @param Name Optional name for the transaction, beginning with a letter
* and containing only letters and digits.
*/
explicit nontransaction( //[t14]
connection_base &C,
const std::string &Name=std::string{}) :
namedclass{"nontransaction", Name}, transaction_base{C} { Begin(); }
virtual ~nontransaction(); //[t14]
private:
virtual void do_begin() override {} //[t14]
virtual result do_exec(const char C[]) override; //[t14]
virtual void do_commit() override {} //[t14]
virtual void do_abort() override {} //[t14]
};
} // namespace pqxx
#include "pqxx/compiler-internal-post.hxx"
#endif
|
