libpqxx  7.5.2
prepared_statement.hxx
1 /* Helper classes for prepared statements and parameterised statements.
2  *
3  * See the connection class for more about such statements.
4  *
5  * Copyright (c) 2000-2021, Jeroen T. Vermeulen.
6  *
7  * See COPYING for copyright license. If you did not receive a file called
8  * COPYING with this source code, please notify the distributor of this
9  * mistake, or contact the author.
10  */
11 #ifndef PQXX_H_PREPARED_STATEMENT
12 #define PQXX_H_PREPARED_STATEMENT
13 
14 #include "pqxx/compiler-public.hxx"
15 #include "pqxx/internal/compiler-internal-pre.hxx"
16 
17 #include "pqxx/internal/statement_parameters.hxx"
18 #include "pqxx/types.hxx"
19 
20 
22 namespace pqxx::prepare
23 {
25 
42 template<typename IT>
43 [[deprecated("Use params instead.")]] constexpr inline auto
44 make_dynamic_params(IT begin, IT end)
45 {
46  return pqxx::internal::dynamic_params(begin, end);
47 }
48 
49 
51 
67 template<typename C>
68 [[nodiscard]] constexpr inline auto make_dynamic_params(C const &container)
69 {
70  using IT = typename C::const_iterator;
71  return pqxx::internal::dynamic_params<IT>{container};
72 }
73 
74 
76 
93 template<typename C, typename ACCESSOR>
94 [[nodiscard]] constexpr inline auto
95 make_dynamic_params(C &container, ACCESSOR accessor)
96 {
97  using IT = decltype(std::begin(container));
98  return pqxx::internal::dynamic_params<IT, ACCESSOR>{container, accessor};
99 }
100 } // namespace pqxx::prepare
101 
102 
103 namespace pqxx
104 {
106 
121 class PQXX_LIBEXPORT params
122 {
123 public:
124  params() = default;
125 
127  template<typename... Args> constexpr params(Args &&...args)
128  {
129  reserve(sizeof...(args));
130  append_pack(std::forward<Args>(args)...);
131  }
132 
133  void reserve(std::size_t);
134  auto size() const { return std::size(m_params); }
135  auto ssize() const { return pqxx::internal::ssize(m_params); }
136 
138  void append();
139 
141 
144  void append(zview);
145 
147 
150  void append(std::string const &);
151 
153  void append(std::string &&);
154 
156 
159  void append(std::basic_string_view<std::byte>);
160 
162 
166  void append(std::basic_string<std::byte> const &);
167 
169  void append(std::basic_string<std::byte> &&);
170 
172 
175  void append(binarystring const &value);
176 
178  template<typename IT, typename ACCESSOR>
179  void append(pqxx::internal::dynamic_params<IT, ACCESSOR> const &value)
180  {
181  for (auto &param : value) append(value.access(param));
182  }
183 
184  void append(params const &value);
185 
186  void append(params &&value);
187 
189  template<typename TYPE> void append(TYPE const &value)
190  {
191  // TODO: Pool storage for multiple string conversions in one buffer?
192  if constexpr (nullness<strip_t<TYPE>>::always_null)
193  {
194  ignore_unused(value);
195  m_params.emplace_back();
196  }
197  else if (is_null(value))
198  {
199  m_params.emplace_back();
200  }
201  else
202  {
203  m_params.emplace_back(entry{to_string(value)});
204  }
205  }
206 
208  template<typename RANGE> void append_multi(RANGE &range)
209  {
210  // TODO: If supported, reserve(std::size(m_params) + std::size(c)).
211  for (auto &value : range) append(value);
212  }
213 
215 
223  pqxx::internal::c_params make_c_params() const;
224 
225 private:
227  template<typename Arg, typename... More>
228  void append_pack(Arg &&arg, More &&...args)
229  {
230  this->append(std::forward<Arg>(arg));
231  // Recurse for remaining args.
232  append_pack(std::forward<More>(args)...);
233  }
234 
236  void append_pack() {}
237 
238  // The way we store a parameter depends on whether it's binary or text (most
239  // types are text), and whether we're responsible for storing the contents.
240  using entry = std::variant<
241  std::nullptr_t, zview, std::string, std::basic_string_view<std::byte>,
242  std::basic_string<std::byte>>;
243  std::vector<entry> m_params;
244 
245  static constexpr std::string_view s_overflow{
246  "Statement parameter length overflow."sv};
247 };
248 } // namespace pqxx
249 
250 #include "pqxx/internal/compiler-internal-post.hxx"
251 #endif
The home of all libpqxx classes, functions, templates, etc.
Definition: array.hxx:26
void ignore_unused(T &&...)
Suppress compiler warning about an unused item.
Definition: util.hxx:71
std::remove_cv_t< std::remove_reference_t< TYPE > > strip_t
Remove any constness, volatile, and reference-ness from a type.
Definition: util.hxx:147
std::string to_string(field const &value)
Convert a field to a string.
Definition: result.cxx:503
bool is_null(TYPE const &value) noexcept
Is value null?
Definition: strconv.hxx:353
auto ssize(T const &c)
Transitional: std::ssize(), or custom implementation if not available.
Definition: util.hxx:312
Dedicated namespace for helper types related to prepared statements.
Definition: prepared_statement.hxx:23
constexpr auto make_dynamic_params(IT begin, IT end)
Pass a number of statement parameters only known at runtime.
Definition: prepared_statement.hxx:44
Binary data corresponding to PostgreSQL's "BYTEA" binary-string type.
Definition: binarystring.hxx:57
Build a parameter list for a parameterised or prepared statement.
Definition: prepared_statement.hxx:122
void append_multi(RANGE &range)
Append all elements of range as parameters.
Definition: prepared_statement.hxx:208
void append(TYPE const &value)
Append a non-null parameter, converting it to its string representation.
Definition: prepared_statement.hxx:189
auto size() const
Definition: prepared_statement.hxx:134
params()=default
auto ssize() const
Definition: prepared_statement.hxx:135
constexpr params(Args &&...args)
Create a params pre-populated with args. Feel free to add more later.
Definition: prepared_statement.hxx:127
void append(pqxx::internal::dynamic_params< IT, ACCESSOR > const &value)
Append all parameters from value.
Definition: prepared_statement.hxx:179
Traits describing a type's "null value," if any.
Definition: strconv.hxx:87
Marker-type wrapper: zero-terminated std::string_view.
Definition: zview.hxx:38