tablewriter.hxx

00001 /*-------------------------------------------------------------------------
00002  *
00003  *   FILE
00004  *      pqxx/tablewriter.hxx
00005  *
00006  *   DESCRIPTION
00007  *      definition of the pqxx::tablewriter class.
00008  *   pqxx::tablewriter enables optimized batch updates to a database table
00009  *   DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/tablewriter.hxx instead.
00010  *
00011  * Copyright (c) 2001-2016, Jeroen T. Vermeulen <jtv@xs4all.nl>
00012  *
00013  * See COPYING for copyright license.  If you did not receive a file called
00014  * COPYING with this source code, please notify the distributor of this mistake,
00015  * or contact the author.
00016  *
00017  *-------------------------------------------------------------------------
00018  */
00019 #ifndef PQXX_H_TABLEWRITER
00020 #define PQXX_H_TABLEWRITER
00021 
00022 #include <iterator>
00023 
00024 #include "pqxx/compiler-public.hxx"
00025 #include "pqxx/compiler-internal-pre.hxx"
00026 #include "pqxx/tablestream"
00027 
00028 namespace pqxx
00029 {
00030 class tablereader;
00032 
00035 class PQXX_LIBEXPORT tablewriter : public tablestream
00036 {
00037 public:
00038   typedef unsigned size_type;
00039   tablewriter(transaction_base &,
00040       const std::string &WName,
00041       const std::string &Null=std::string());
00042   template<typename ITER> tablewriter(transaction_base &,
00043       const std::string &WName,
00044       ITER begincolumns,
00045       ITER endcolumns);
00046   template<typename ITER> tablewriter(transaction_base &T,
00047       const std::string &WName,
00048       ITER begincolumns,
00049       ITER endcolumns,
00050       const std::string &Null);
00051   ~tablewriter() PQXX_NOEXCEPT;
00052   template<typename IT> void insert(IT Begin, IT End);
00053   template<typename TUPLE> void insert(const TUPLE &);
00054   template<typename IT> void push_back(IT Begin, IT End);
00055   template<typename TUPLE> void push_back(const TUPLE &);
00056   void reserve(size_type) {}
00057   template<typename TUPLE> tablewriter &operator<<(const TUPLE &);
00058   tablewriter &operator<<(tablereader &);
00059   template<typename IT> std::string generate(IT Begin, IT End) const;
00060   template<typename TUPLE> std::string generate(const TUPLE &) const;
00061   virtual void complete() PQXX_OVERRIDE;
00062   void write_raw_line(const std::string &);
00063 private:
00064   void setup(transaction_base &,
00065       const std::string &WName,
00066       const std::string &Columns = std::string());
00067   PQXX_PRIVATE void writer_close();
00068 };
00069 } // namespace pqxx
00070 namespace std
00071 {
00072 template<>
00073   class back_insert_iterator<pqxx::tablewriter> :
00074         public iterator<output_iterator_tag, void,void,void,void>
00075 {
00076 public:
00077   explicit back_insert_iterator(pqxx::tablewriter &W) PQXX_NOEXCEPT :
00078     m_Writer(&W) {}
00079   back_insert_iterator &
00080     operator=(const back_insert_iterator &rhs) PQXX_NOEXCEPT
00081   {
00082     m_Writer = rhs.m_Writer;
00083     return *this;
00084   }
00085   template<typename TUPLE>
00086   back_insert_iterator &operator=(const TUPLE &T)
00087   {
00088     m_Writer->insert(T);
00089     return *this;
00090   }
00091   back_insert_iterator &operator++() { return *this; }
00092   back_insert_iterator &operator++(int) { return *this; }
00093   back_insert_iterator &operator*() { return *this; }
00094 private:
00095   pqxx::tablewriter *m_Writer;
00096 };
00097 } // namespace std
00098 namespace pqxx
00099 {
00100 template<typename ITER> inline tablewriter::tablewriter(transaction_base &T,
00101     const std::string &WName,
00102     ITER begincolumns,
00103     ITER endcolumns) :
00104   namedclass("tablewriter", WName),
00105   tablestream(T, std::string())
00106 {
00107   setup(T, WName, columnlist(begincolumns, endcolumns));
00108 }
00109 template<typename ITER> inline tablewriter::tablewriter(transaction_base &T,
00110     const std::string &WName,
00111     ITER begincolumns,
00112     ITER endcolumns,
00113     const std::string &Null) :
00114   namedclass("tablewriter", WName),
00115   tablestream(T, Null)
00116 {
00117   setup(T, WName, columnlist(begincolumns, endcolumns));
00118 }
00119 namespace internal
00120 {
00121 PQXX_LIBEXPORT std::string Escape(
00122         const std::string &s,
00123         const std::string &null);
00124 inline std::string EscapeAny(
00125         const std::string &s,
00126         const std::string &null)
00127 { return Escape(s, null); }
00128 inline std::string EscapeAny(
00129         const char s[],
00130         const std::string &null)
00131 { return s ? Escape(std::string(s), null) : "\\N"; }
00132 template<typename T> inline std::string EscapeAny(
00133         const T &t,
00134         const std::string &null)
00135 { return Escape(to_string(t), null); }
00136 template<typename IT> class Escaper
00137 {
00138   const std::string &m_null;
00139 public:
00140   explicit Escaper(const std::string &null) : m_null(null) {}
00141   std::string operator()(IT i) const { return EscapeAny(*i, m_null); }
00142 };
00143 }
00144 template<typename IT>
00145 inline std::string tablewriter::generate(IT Begin, IT End) const
00146 {
00147   return separated_list("\t", Begin, End, internal::Escaper<IT>(NullStr()));
00148 }
00149 template<typename TUPLE>
00150 inline std::string tablewriter::generate(const TUPLE &T) const
00151 {
00152   return generate(T.begin(), T.end());
00153 }
00154 template<typename IT> inline void tablewriter::insert(IT Begin, IT End)
00155 {
00156   write_raw_line(generate(Begin, End));
00157 }
00158 template<typename TUPLE> inline void tablewriter::insert(const TUPLE &T)
00159 {
00160   insert(T.begin(), T.end());
00161 }
00162 template<typename IT>
00163 inline void tablewriter::push_back(IT Begin, IT End)
00164 {
00165   insert(Begin, End);
00166 }
00167 template<typename TUPLE>
00168 inline void tablewriter::push_back(const TUPLE &T)
00169 {
00170   insert(T.begin(), T.end());
00171 }
00172 template<typename TUPLE>
00173 inline tablewriter &tablewriter::operator<<(const TUPLE &T)
00174 {
00175   insert(T);
00176   return *this;
00177 }
00178 } // namespace pqxx
00179 #include "pqxx/compiler-internal-post.hxx"
00180 #endif

Generated on 16 Mar 2017 for libpqxx by  doxygen 1.6.1