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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
/** Helper classes for defining and executing prepared statements.
*
* See the connection_base hierarchy for more about prepared statements.
*
* 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_PREPARED_STATEMENT
#define PQXX_H_PREPARED_STATEMENT
#include "pqxx/compiler-public.hxx"
#include "pqxx/compiler-internal-pre.hxx"
#include "pqxx/types.hxx"
#include "pqxx/internal/statement_parameters.hxx"
namespace pqxx
{
/// Dedicated namespace for helper types related to prepared statements.
namespace prepare
{
/// Pass a number of statement parameters only known at runtime.
/** When you call any of the @c exec_params functions, the number of arguments
* is normally known at compile time. This helper function supports the case
* where it is not.
*
* Use this function to pass a variable number of parameters, based on a
* sequence ranging from @c begin to @c end exclusively.
*
* The technique combines with the regular static parameters. You can use it
* to insert dynamic parameter lists in any place, or places, among the call's
* parameters. You can even insert multiple dynamic sequences.
*
* @param begin A pointer or iterator for iterating parameters.
* @param end A pointer or iterator for iterating parameters.
* @return An object representing the parameters.
*/
template<typename IT> inline pqxx::internal::dynamic_params<IT>
make_dynamic_params(IT begin, IT end)
{
return pqxx::internal::dynamic_params<IT>(begin, end);
}
/// Pass a number of statement parameters only known at runtime.
/** When you call any of the @c exec_params functions, the number of arguments
* is normally known at compile time. This helper function supports the case
* where it is not.
*
* Use this function to pass a variable number of parameters, based on a
* container of parameter values.
*
* The technique combines with the regular static parameters. You can use it
* to insert dynamic parameter lists in any place, or places, among the call's
* parameters. You can even insert multiple dynamic containers.
*
* @param container A container of parameter values.
* @return An object representing the parameters.
*/
template<typename C>
inline pqxx::internal::dynamic_params<typename C::const_iterator>
make_dynamic_params(const C &container)
{
return pqxx::internal::dynamic_params<typename C::const_iterator>(container);
}
} // namespace prepare
} // namespace pqxx
namespace pqxx
{
namespace prepare
{
/// Helper class for passing parameters to, and executing, prepared statements
/** @deprecated As of 6.0, use @c transaction_base::exec_prepared and friends.
*/
class PQXX_LIBEXPORT invocation : internal::statement_parameters
{
public:
PQXX_DEPRECATED invocation(transaction_base &, const std::string &statement);
invocation &operator=(const invocation &) =delete;
/// Execute!
result exec() const;
/// Execute and return result in binary format
result exec_binary() const;
/// Has a statement of this name been defined?
bool exists() const;
/// Pass null parameter.
invocation &operator()() { add_param(); return *this; }
/// Pass parameter value.
/**
* @param v parameter value; will be represented as a string internally.
*/
template<typename T> invocation &operator()(const T &v)
{ add_param(v, true); return *this; }
/// Pass binary parameter value for a BYTEA field.
/**
* @param v binary string; will be passed on directly in binary form.
*/
invocation &operator()(const binarystring &v)
{ add_binary_param(v, true); return *this; }
/// Pass parameter value.
/**
* @param v parameter value (will be represented as a string internally).
* @param nonnull replaces value with null if set to false.
*/
template<typename T> invocation &operator()(const T &v, bool nonnull)
{ add_param(v, nonnull); return *this; }
/// Pass binary parameter value for a BYTEA field.
/**
* @param v binary string; will be passed on directly in binary form.
* @param nonnull determines whether to pass a real value, or nullptr.
*/
invocation &operator()(const binarystring &v, bool nonnull)
{ add_binary_param(v, nonnull); return *this; }
/// Pass C-style parameter string, or null if pointer is null.
/**
* This version is for passing C-style strings; it's a template, so any
* pointer type that @c to_string accepts will do.
*
* @param v parameter value (will be represented as a C++ string internally)
* @param nonnull replaces value with null if set to @c false
*/
template<typename T> invocation &operator()(T *v, bool nonnull=true)
{ add_param(v, nonnull); return *this; }
/// Pass C-style string parameter, or null if pointer is null.
/** This duplicates the pointer-to-template-argument-type version of the
* operator, but helps compilers with less advanced template implementations
* disambiguate calls where C-style strings are passed.
*/
invocation &operator()(const char *v, bool nonnull=true)
{ add_param(v, nonnull); return *this; }
private:
transaction_base &m_home;
const std::string m_statement;
invocation &setparam(const std::string &, bool nonnull);
result internal_exec(result_format format) const;
};
namespace internal
{
/// Internal representation of a prepared statement definition.
struct PQXX_LIBEXPORT prepared_def
{
/// Text of prepared query.
std::string definition;
/// Has this prepared statement been prepared in the current session?
bool registered = false;
prepared_def() =default;
explicit prepared_def(const std::string &);
};
} // namespace pqxx::prepare::internal
} // namespace pqxx::prepare
} // namespace pqxx
#include "pqxx/compiler-internal-post.hxx"
#endif
|
