13 #ifndef PQXX_H_STREAM_TO
14 #define PQXX_H_STREAM_TO
16 #if !defined(PQXX_HEADER_PRE)
17 # error "Include libpqxx headers as <pqxx/header>, not <pqxx/header.hxx>."
20 #include "pqxx/separated_list.hxx"
21 #include "pqxx/transaction_base.hxx"
107 return {tx, path, columns};
122 std::initializer_list<std::string_view> columns = {})
124 auto const &conn{tx.
conn()};
125 return raw_table(tx, conn.quote_table(path), conn.quote_columns(columns));
128 #if defined(PQXX_HAVE_CONCEPTS)
137 template<PQXX_CHAR_STRINGS_ARG COLUMNS>
139 table(transaction_base &tx,
table_path path, COLUMNS
const &columns)
141 auto const &conn{tx.conn()};
143 tx, conn.quote_table(path), tx.conn().quote_columns(columns));
154 template<PQXX_CHAR_STRINGS_ARG COLUMNS>
156 table(transaction_base &tx, std::string_view path, COLUMNS
const &columns)
172 [[deprecated(
"Use table() or raw_table() factory.")]]
stream_to(
180 template<
typename Columns>
181 [[deprecated(
"Use table() or raw_table() factory.")]]
stream_to(
187 template<
typename Iter>
188 [[deprecated(
"Use table() or raw_table() factory.")]]
stream_to(
195 m_finished{other.m_finished},
196 m_buffer{std::move(other.m_buffer)},
197 m_field_buf{std::move(other.m_field_buf)},
198 m_finder{other.m_finder}
200 other.m_finished =
true;
205 [[nodiscard]] constexpr operator
bool() const noexcept
207 return not m_finished;
266 fill_buffer(fields...);
275 bool m_finished =
false;
278 std::string m_buffer;
281 std::string m_field_buf;
284 internal::char_finder_func *m_finder;
287 void write_raw_line(std::string_view);
295 static constexpr std::string_view null_field{
"\\N\t"};
299 static std::enable_if_t<nullness<T>::always_null, std::size_t>
300 estimate_buffer(T
const &)
302 return std::size(null_field);
310 static std::enable_if_t<not nullness<T>::always_null, std::size_t>
311 estimate_buffer(T
const &field)
317 void escape_field_to_buffer(std::string_view data);
326 template<
typename Field>
327 std::enable_if_t<not nullness<Field>::always_null>
328 append_to_buffer(Field
const &f)
336 m_buffer.append(null_field);
342 using traits = string_traits<Field>;
343 auto const budget{estimate_buffer(f)};
344 auto const offset{std::size(m_buffer)};
346 if constexpr (std::is_arithmetic_v<Field>)
354 auto const total{offset + budget};
355 m_buffer.resize(total);
356 auto const data{m_buffer.data()};
357 char *
const end{traits::into_buf(data + offset, data + total, f)};
360 m_buffer.resize(
static_cast<std::size_t
>(end - data));
363 std::is_same_v<Field, std::string> or
364 std::is_same_v<Field, std::string_view> or
365 std::is_same_v<Field, zview>)
368 m_field_buf.resize(budget);
369 escape_field_to_buffer(f);
372 std::is_same_v<Field, std::optional<std::string>> or
373 std::is_same_v<Field, std::optional<std::string_view>> or
374 std::is_same_v<Field, std::optional<zview>>)
378 m_field_buf.resize(budget);
379 escape_field_to_buffer(f.value());
383 std::is_same_v<Field, std::unique_ptr<std::string>> or
384 std::is_same_v<Field, std::unique_ptr<std::string_view>> or
385 std::is_same_v<Field, std::unique_ptr<zview>> or
386 std::is_same_v<Field, std::shared_ptr<std::string>> or
387 std::is_same_v<Field, std::shared_ptr<std::string_view>> or
388 std::is_same_v<Field, std::shared_ptr<zview>>)
393 m_field_buf.resize(budget);
394 escape_field_to_buffer(*f);
400 m_field_buf.resize(budget);
401 auto const data{m_field_buf.data()};
402 escape_field_to_buffer(
403 traits::to_buf(data, data + std::size(m_field_buf), f));
415 template<
typename Field>
416 std::enable_if_t<nullness<Field>::always_null>
417 append_to_buffer(Field
const &)
419 m_buffer.append(null_field);
423 template<
typename Container>
424 std::enable_if_t<not std::is_same_v<typename Container::value_type, char>>
425 fill_buffer(Container
const &c)
430 std::size_t budget{0};
431 for (
auto const &f : c) budget += estimate_buffer(f);
432 m_buffer.reserve(budget);
433 for (
auto const &f : c) append_to_buffer(f);
437 template<
typename Tuple, std::size_t... indexes>
439 budget_tuple(Tuple
const &t, std::index_sequence<indexes...>)
441 return (estimate_buffer(std::get<indexes>(t)) + ...);
445 template<
typename Tuple, std::size_t... indexes>
446 void append_tuple(Tuple
const &t, std::index_sequence<indexes...>)
448 (append_to_buffer(std::get<indexes>(t)), ...);
452 template<
typename... Elts>
void fill_buffer(std::tuple<Elts...>
const &t)
454 using indexes = std::make_index_sequence<
sizeof...(Elts)>;
456 m_buffer.reserve(budget_tuple(t, indexes{}));
457 append_tuple(t, indexes{});
461 template<
typename... Ts>
void fill_buffer(
const Ts &...fields)
463 (..., append_to_buffer(fields));
466 constexpr
static std::string_view s_classname{
"stream_to"};
470 template<
typename Columns>
472 transaction_base &tx, std::string_view table_name, Columns
const &columns) :
473 stream_to{tx, table_name, std::begin(columns), std::end(columns)}
477 template<
typename Iter>
The home of all libpqxx classes, functions, templates, etc.
Definition: array.hxx:33
std::string separated_list(std::string_view sep, ITER begin, ITER end, ACCESS access)
Represent sequence of values as a string, joined by a given separator.
Definition: separated_list.hxx:44
std::size_t size_buffer(TYPE const &...value) noexcept
Estimate how much buffer space is needed to represent values as a string.
Definition: strconv.hxx:519
std::initializer_list< std::string_view > table_path
Representation of a PostgreSQL table path.
Definition: connection.hxx:185
constexpr bool is_null(TYPE const &value) noexcept
Is value null?
Definition: strconv.hxx:508
std::basic_ostream< CHAR > & operator<<(std::basic_ostream< CHAR > &s, field const &value)
Write a result field to any type of stream.
Definition: field.hxx:509
Reference to one row in a result.
Definition: row.hxx:47
Stream data from the database.
Definition: stream_from.hxx:79
Efficiently write data directly to a database table.
Definition: stream_to.hxx:81
static stream_to raw_table(transaction_base &tx, std::string_view path, std::string_view columns="")
Stream data to a pre-quoted table and columns.
Definition: stream_to.hxx:104
stream_to & operator<<(Row const &row)
Insert a row of data.
Definition: stream_to.hxx:234
constexpr bool operator!() const noexcept
Has this stream been through its concluding complete()?
Definition: stream_to.hxx:210
static stream_to table(transaction_base &tx, table_path path, std::initializer_list< std::string_view > columns={})
Create a stream_to writing to a named table and columns.
Definition: stream_to.hxx:120
void write_values(Ts const &...fields)
Insert values as a row.
Definition: stream_to.hxx:264
stream_to(transaction_base &tx, std::string_view table_name)
Create a stream, without specifying columns.
Definition: stream_to.hxx:172
stream_to(stream_to &&other)
Definition: stream_to.hxx:192
void write_row(Row const &row)
Insert a row of data, given in the form of a std::tuple or container.
Definition: stream_to.hxx:254
Interface definition (and common code) for "transaction" classes.
Definition: transaction_base.hxx:88
std::string quote_name(std::string_view identifier) const
Escape an SQL identifier for use in a query.
Definition: transaction_base.hxx:231
constexpr connection & conn() const noexcept
The connection in which this transaction lives.
Definition: transaction_base.hxx:792
Base class for things that monopolise a transaction's attention.
Definition: transaction_focus.hxx:29