database.hxx   database.hxx 
skipping to change at line 41 skipping to change at line 41
namespace sqlite namespace sqlite
{ {
class transaction_impl; class transaction_impl;
class LIBODB_SQLITE_EXPORT database: public odb::database class LIBODB_SQLITE_EXPORT database: public odb::database
{ {
public: public:
database (const std::string& name, database (const std::string& name,
int flags = SQLITE_OPEN_READWRITE, int flags = SQLITE_OPEN_READWRITE,
bool foreign_keys = true, bool foreign_keys = true,
const std::string& vfs = "",
details::transfer_ptr<connection_factory> = details::transfer_ptr<connection_factory> =
details::transfer_ptr<connection_factory> ()); details::transfer_ptr<connection_factory> ());
#ifdef _WIN32
database (const std::wstring& name,
int flags = SQLITE_OPEN_READWRITE,
bool foreign_keys = true,
const std::string& vfs = "",
details::transfer_ptr<connection_factory> =
details::transfer_ptr<connection_factory> ());
#endif
// Extract the database parameters from the command line. The // Extract the database parameters from the command line. The
// following options are recognized: // following options are recognized:
// //
// --database // --database
// --create // --create
// --read-only // --read-only
// --options-file // --options-file
// //
// For more information, see the output of the print_usage() function // For more information, see the output of the print_usage() function
// below. If erase is true, the above options are removed from the ar gv // below. If erase is true, the above options are removed from the ar gv
// array and the argc count is updated accordingly. The command line // array and the argc count is updated accordingly. The command line
// options override the flags passed as an argument. This constructor // options override the flags passed as an argument. This constructor
// may throw the cli_exception exception. // may throw the cli_exception exception.
// //
database (int& argc, database (int& argc,
char* argv[], char* argv[],
bool erase = false, bool erase = false,
int flags = SQLITE_OPEN_READWRITE, int flags = SQLITE_OPEN_READWRITE,
bool foreign_keys = true, bool foreign_keys = true,
const std::string& vfs = "",
details::transfer_ptr<connection_factory> = details::transfer_ptr<connection_factory> =
details::transfer_ptr<connection_factory> ()); details::transfer_ptr<connection_factory> ());
static void static void
print_usage (std::ostream&); print_usage (std::ostream&);
public: public:
const std::string& const std::string&
name () const name () const
{ {
skipping to change at line 88 skipping to change at line 99
{ {
return flags_; return flags_;
} }
bool bool
foreign_keys () const foreign_keys () const
{ {
return foreign_keys_; return foreign_keys_;
} }
const std::string&
vfs () const
{
return vfs_;
}
// Transactions. // Transactions.
// //
public: public:
virtual transaction_impl* virtual transaction_impl*
begin (); begin ();
transaction_impl* transaction_impl*
begin_immediate (); begin_immediate ();
transaction_impl* transaction_impl*
skipping to change at line 135 skipping to change at line 152
~database (); ~database ();
protected: protected:
virtual odb::connection* virtual odb::connection*
connection_ (); connection_ ();
private: private:
std::string name_; std::string name_;
int flags_; int flags_;
bool foreign_keys_; bool foreign_keys_;
std::string vfs_;
details::unique_ptr<connection_factory> factory_; details::unique_ptr<connection_factory> factory_;
}; };
} }
} }
#include <odb/sqlite/database.ixx> #include <odb/sqlite/database.ixx>
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_SQLITE_DATABASE_HXX #endif // ODB_SQLITE_DATABASE_HXX
 End of changes. 5 change blocks. 
0 lines changed or deleted 18 lines changed or added


 options.hxx   options.hxx 
// This code was generated by CLI, a command line interface // This code was generated by CLI, a command line interface
// compiler for C++. // compiler for C++.
// //
#ifndef LIBODB_SQLITE_DETAILS_OPTIONS_HXX #ifndef LIBODB_SQLITE_DETAILS_OPTIONS_HXX
#define LIBODB_SQLITE_DETAILS_OPTIONS_HXX #define LIBODB_SQLITE_DETAILS_OPTIONS_HXX
// Begin prologue.
//
//
// End prologue.
#include <deque> #include <deque>
#include <iosfwd> #include <iosfwd>
#include <string> #include <string>
#include <cstddef> #include <cstddef>
#include <exception> #include <exception>
namespace odb namespace odb
{ {
namespace sqlite namespace sqlite
{ {
skipping to change at line 50 skipping to change at line 55
value v_; value v_;
}; };
// Exceptions. // Exceptions.
// //
class exception: public std::exception class exception: public std::exception
{ {
public: public:
virtual void virtual void
print (std::ostream&) const = 0; print (::std::ostream&) const = 0;
}; };
std::ostream& ::std::ostream&
operator<< (std::ostream&, const exception&); operator<< (::std::ostream&, const exception&);
class unknown_option: public exception class unknown_option: public exception
{ {
public: public:
virtual virtual
~unknown_option () throw (); ~unknown_option () throw ();
unknown_option (const std::string& option); unknown_option (const std::string& option);
const std::string& const std::string&
option () const; option () const;
virtual void virtual void
print (std::ostream&) const; print (::std::ostream&) const;
virtual const char* virtual const char*
what () const throw (); what () const throw ();
private: private:
std::string option_; std::string option_;
}; };
class unknown_argument: public exception class unknown_argument: public exception
{ {
public: public:
virtual virtual
~unknown_argument () throw (); ~unknown_argument () throw ();
unknown_argument (const std::string& argument); unknown_argument (const std::string& argument);
const std::string& const std::string&
argument () const; argument () const;
virtual void virtual void
print (std::ostream&) const; print (::std::ostream&) const;
virtual const char* virtual const char*
what () const throw (); what () const throw ();
private: private:
std::string argument_; std::string argument_;
}; };
class missing_value: public exception class missing_value: public exception
{ {
public: public:
virtual virtual
~missing_value () throw (); ~missing_value () throw ();
missing_value (const std::string& option); missing_value (const std::string& option);
const std::string& const std::string&
option () const; option () const;
virtual void virtual void
print (std::ostream&) const; print (::std::ostream&) const;
virtual const char* virtual const char*
what () const throw (); what () const throw ();
private: private:
std::string option_; std::string option_;
}; };
class invalid_value: public exception class invalid_value: public exception
{ {
skipping to change at line 135 skipping to change at line 140
invalid_value (const std::string& option, invalid_value (const std::string& option,
const std::string& value); const std::string& value);
const std::string& const std::string&
option () const; option () const;
const std::string& const std::string&
value () const; value () const;
virtual void virtual void
print (std::ostream&) const; print (::std::ostream&) const;
virtual const char* virtual const char*
what () const throw (); what () const throw ();
private: private:
std::string option_; std::string option_;
std::string value_; std::string value_;
}; };
class eos_reached: public exception class eos_reached: public exception
{ {
public: public:
virtual void virtual void
print (std::ostream&) const; print (::std::ostream&) const;
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
class file_io_failure: public exception class file_io_failure: public exception
{ {
public: public:
virtual virtual
~file_io_failure () throw (); ~file_io_failure () throw ();
file_io_failure (const std::string& file); file_io_failure (const std::string& file);
const std::string& const std::string&
file () const; file () const;
virtual void virtual void
print (std::ostream&) const; print (::std::ostream&) const;
virtual const char* virtual const char*
what () const throw (); what () const throw ();
private: private:
std::string file_; std::string file_;
}; };
class unmatched_quote: public exception class unmatched_quote: public exception
{ {
public: public:
virtual virtual
~unmatched_quote () throw (); ~unmatched_quote () throw ();
unmatched_quote (const std::string& argument); unmatched_quote (const std::string& argument);
const std::string& const std::string&
argument () const; argument () const;
virtual void virtual void
print (std::ostream&) const; print (::std::ostream&) const;
virtual const char* virtual const char*
what () const throw (); what () const throw ();
private: private:
std::string argument_; std::string argument_;
}; };
class scanner class scanner
{ {
skipping to change at line 312 skipping to change at line 317
const std::string option_; const std::string option_;
option_info option_info_; option_info option_info_;
const option_info* options_; const option_info* options_;
std::size_t options_count_; std::size_t options_count_;
std::string hold_; std::string hold_;
std::deque<std::string> args_; std::deque<std::string> args_;
bool skip_; bool skip_;
}; };
template <typename X>
struct parser;
} }
} }
} }
} }
#include <string> #include <string>
namespace odb namespace odb
{ {
namespace sqlite namespace sqlite
{ {
namespace details namespace details
{ {
class options class options
{ {
public: public:
options (int& argc, options (int& argc,
char** argv, char** argv,
bool erase = false, bool erase = false,
::odb::sqlite::details::cli::unknown_mode option = ::odb:: sqlite::details::cli::unknown_mode::fail, ::odb::sqlite::details::cli::unknown_mode option = ::odb:: sqlite::details::cli::unknown_mode::fail,
::odb::sqlite::details::cli::unknown_mode argument = ::odb ::sqlite::details::cli::unknown_mode::stop); ::odb::sqlite::details::cli::unknown_mode argument = ::odb ::sqlite::details::cli::unknown_mode::stop);
options (int start, options (int start,
int& argc, int& argc,
char** argv, char** argv,
bool erase = false, bool erase = false,
skipping to change at line 361 skipping to change at line 368
char** argv, char** argv,
int& end, int& end,
bool erase = false, bool erase = false,
::odb::sqlite::details::cli::unknown_mode option = ::odb:: sqlite::details::cli::unknown_mode::fail, ::odb::sqlite::details::cli::unknown_mode option = ::odb:: sqlite::details::cli::unknown_mode::fail,
::odb::sqlite::details::cli::unknown_mode argument = ::odb ::sqlite::details::cli::unknown_mode::stop); ::odb::sqlite::details::cli::unknown_mode argument = ::odb ::sqlite::details::cli::unknown_mode::stop);
options (::odb::sqlite::details::cli::scanner&, options (::odb::sqlite::details::cli::scanner&,
::odb::sqlite::details::cli::unknown_mode option = ::odb:: sqlite::details::cli::unknown_mode::fail, ::odb::sqlite::details::cli::unknown_mode option = ::odb:: sqlite::details::cli::unknown_mode::fail,
::odb::sqlite::details::cli::unknown_mode argument = ::odb ::sqlite::details::cli::unknown_mode::stop); ::odb::sqlite::details::cli::unknown_mode argument = ::odb ::sqlite::details::cli::unknown_mode::stop);
options ();
// Option accessors. // Option accessors.
// //
const std::string& const std::string&
database () const; database () const;
const bool& const bool&
create () const; create () const;
const bool& const bool&
read_only () const; read_only () const;
const std::string& const std::string&
options_file () const; options_file () const;
// Print usage information. // Print usage information.
// //
static void static void
print_usage (::std::ostream&); print_usage (::std::ostream&);
// Implementation details.
//
protected:
bool
_parse (const char*, ::odb::sqlite::details::cli::scanner&);
private: private:
void void
_parse (::odb::sqlite::details::cli::scanner&, _parse (::odb::sqlite::details::cli::scanner&,
::odb::sqlite::details::cli::unknown_mode option, ::odb::sqlite::details::cli::unknown_mode option,
::odb::sqlite::details::cli::unknown_mode argument); ::odb::sqlite::details::cli::unknown_mode argument);
public: public:
std::string database_; std::string database_;
bool create_; bool create_;
bool read_only_; bool read_only_;
std::string options_file_; std::string options_file_;
}; };
} }
} }
} }
#include "options.ixx" #include "options.ixx"
// Begin epilogue.
//
//
// End epilogue.
#endif // LIBODB_SQLITE_DETAILS_OPTIONS_HXX #endif // LIBODB_SQLITE_DETAILS_OPTIONS_HXX
 End of changes. 16 change blocks. 
12 lines changed or deleted 31 lines changed or added


 options.ixx   options.ixx 
// This code was generated by CLI, a command line interface // This code was generated by CLI, a command line interface
// compiler for C++. // compiler for C++.
// //
// Begin prologue.
//
//
// End prologue.
namespace odb namespace odb
{ {
namespace sqlite namespace sqlite
{ {
namespace details namespace details
{ {
namespace cli namespace cli
{ {
// unknown_mode // unknown_mode
// //
inline unknown_mode:: inline unknown_mode::
unknown_mode (value v) unknown_mode (value v)
: v_ (v) : v_ (v)
{ {
} }
// exception // exception
// //
inline std::ostream& inline ::std::ostream&
operator<< (std::ostream& os, const exception& e) operator<< (::std::ostream& os, const exception& e)
{ {
e.print (os); e.print (os);
return os; return os;
} }
// unknown_option // unknown_option
// //
inline unknown_option:: inline unknown_option::
unknown_option (const std::string& option) unknown_option (const std::string& option)
: option_ (option) : option_ (option)
skipping to change at line 240 skipping to change at line 245
} }
inline const std::string& options:: inline const std::string& options::
options_file () const options_file () const
{ {
return this->options_file_; return this->options_file_;
} }
} }
} }
} }
// Begin epilogue.
//
//
// End epilogue.
 End of changes. 3 change blocks. 
2 lines changed or deleted 7 lines changed or added


 query.hxx   query.hxx 
skipping to change at line 23 skipping to change at line 23
#include <odb/query.hxx> #include <odb/query.hxx>
#include <odb/details/buffer.hxx> #include <odb/details/buffer.hxx>
#include <odb/details/shared-ptr.hxx> #include <odb/details/shared-ptr.hxx>
#include <odb/sqlite/version.hxx> #include <odb/sqlite/version.hxx>
#include <odb/sqlite/forward.hxx> #include <odb/sqlite/forward.hxx>
#include <odb/sqlite/traits.hxx> #include <odb/sqlite/traits.hxx>
#include <odb/sqlite/sqlite-types.hxx> #include <odb/sqlite/sqlite-types.hxx>
#include <odb/sqlite/binding.hxx> #include <odb/sqlite/binding.hxx>
#include <odb/sqlite/details/export.hxx> #include <odb/sqlite/details/export.hxx>
#include <odb/sqlite/details/conversion.hxx>
namespace odb namespace odb
{ {
namespace sqlite namespace sqlite
{ {
template <typename T> template <typename T>
class val_bind class val_bind
{ {
public: public:
explicit explicit
skipping to change at line 132 skipping to change at line 134
param, param,
native, native,
boolean boolean
}; };
clause_part (kind_type k): kind (k) {} clause_part (kind_type k): kind (k) {}
clause_part (kind_type k, const std::string& p): kind (k), part (p) {} clause_part (kind_type k, const std::string& p): kind (k), part (p) {}
clause_part (bool p): kind (boolean), bool_part (p) {} clause_part (bool p): kind (boolean), bool_part (p) {}
kind_type kind; kind_type kind;
std::string part; std::string part; // If kind is param, then part is conversion expr .
bool bool_part; bool bool_part;
}; };
query () query ()
: parameters_ (new (details::shared) query_params) : parameters_ (new (details::shared) query_params)
{ {
} }
// True or false literal. // True or false literal.
// //
skipping to change at line 175 skipping to change at line 177
: parameters_ (new (details::shared) query_params) : parameters_ (new (details::shared) query_params)
{ {
append (table, column); append (table, column);
} }
template <typename T> template <typename T>
explicit explicit
query (val_bind<T> v) query (val_bind<T> v)
: parameters_ (new (details::shared) query_params) : parameters_ (new (details::shared) query_params)
{ {
append<T, type_traits<T>::db_type_id> (v); append<T, type_traits<T>::db_type_id> (
v, details::conversion<T>::to ());
} }
template <typename T> template <typename T>
explicit explicit
query (ref_bind<T> r) query (ref_bind<T> r)
: parameters_ (new (details::shared) query_params) : parameters_ (new (details::shared) query_params)
{ {
append<T, type_traits<T>::db_type_id> (r); append<T, type_traits<T>::db_type_id> (
r, details::conversion<T>::to ());
} }
template <database_type_id ID> template <database_type_id ID>
query (const query_column<bool, ID>&); query (const query_column<bool, ID>&);
query (const query&); query (const query&);
query& query&
operator= (const query&); operator= (const query&);
skipping to change at line 257 skipping to change at line 261
operator+= (const std::string& q) operator+= (const std::string& q)
{ {
append (q); append (q);
return *this; return *this;
} }
template <typename T> template <typename T>
query& query&
operator+= (val_bind<T> v) operator+= (val_bind<T> v)
{ {
append<T, type_traits<T>::db_type_id> (v); append<T, type_traits<T>::db_type_id> (
v, details::conversion<T>::to ());
return *this; return *this;
} }
template <typename T> template <typename T>
query& query&
operator+= (ref_bind<T> r) operator+= (ref_bind<T> r)
{ {
append<T, type_traits<T>::db_type_id> (r); append<T, type_traits<T>::db_type_id> (
r, details::conversion<T>::to ());
return *this; return *this;
} }
public: public:
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
void void
append (val_bind<T>); append (val_bind<T>, const char* conv);
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
void void
append (ref_bind<T>); append (ref_bind<T>, const char* conv);
void void
append (const std::string& native); append (const std::string& native);
void void
append (const char* table, const char* column); append (const char* table, const char* column);
private: private:
void void
add (details::shared_ptr<query_param>); add (details::shared_ptr<query_param>, const char* conv);
private: private:
typedef std::vector<clause_part> clause_type; typedef std::vector<clause_part> clause_type;
clause_type clause_; clause_type clause_;
details::shared_ptr<query_params> parameters_; details::shared_ptr<query_params> parameters_;
}; };
inline query inline query
operator+ (const query& x, const query& y) operator+ (const query& x, const query& y)
skipping to change at line 424 skipping to change at line 430
const T val; const T val;
}; };
template <typename T> template <typename T>
const T& const T&
type_instance (); type_instance ();
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
struct query_column struct query_column
{ {
// Note that we keep shalow copies of the table and column names. // Note that we keep shallow copies of the table, column, and convers
ion
// expression. The latter can be NULL.
// //
query_column (const char* table, const char* column) query_column (const char* table, const char* column, const char* conv
: table_ (table), column_ (column) )
: table_ (table), column_ (column), conversion_ (conv)
{ {
} }
const char* const char*
table () const table () const
{ {
return table_; return table_;
} }
const char* const char*
column () const column () const
{ {
return column_; return column_;
} }
// Can be NULL.
//
const char*
conversion () const
{
return conversion_;
}
// is_null, is_not_null // is_null, is_not_null
// //
public: public:
query query
is_null () const is_null () const
{ {
query q (table_, column_); query q (table_, column_);
q += "IS NULL"; q += "IS NULL";
return q; return q;
} }
skipping to change at line 495 skipping to change at line 510
equal (const T& v) const equal (const T& v) const
{ {
return equal (val_bind<T> (v)); return equal (val_bind<T> (v));
} }
query query
equal (val_bind<T> v) const equal (val_bind<T> v) const
{ {
query q (table_, column_); query q (table_, column_);
q += "="; q += "=";
q.append<T, ID> (v); q.append<T, ID> (v, conversion_);
return q; return q;
} }
template <typename T2> template <typename T2>
query query
equal (val_bind<T2> v) const equal (val_bind<T2> v) const
{ {
copy_bind<T, T2> c (v.val); copy_bind<T, T2> c (v.val);
return equal (c); return equal (c);
} }
query query
equal (ref_bind<T> r) const equal (ref_bind<T> r) const
{ {
query q (table_, column_); query q (table_, column_);
q += "="; q += "=";
q.append<T, ID> (r); q.append<T, ID> (r, conversion_);
return q; return q;
} }
friend query friend query
operator== (const query_column& c, const T& v) operator== (const query_column& c, const T& v)
{ {
return c.equal (v); return c.equal (v);
} }
friend query friend query
skipping to change at line 580 skipping to change at line 595
unequal (const T& v) const unequal (const T& v) const
{ {
return unequal (val_bind<T> (v)); return unequal (val_bind<T> (v));
} }
query query
unequal (val_bind<T> v) const unequal (val_bind<T> v) const
{ {
query q (table_, column_); query q (table_, column_);
q += "!="; q += "!=";
q.append<T, ID> (v); q.append<T, ID> (v, conversion_);
return q; return q;
} }
template <typename T2> template <typename T2>
query query
unequal (val_bind<T2> v) const unequal (val_bind<T2> v) const
{ {
copy_bind<T, T2> c (v.val); copy_bind<T, T2> c (v.val);
return unequal (c); return unequal (c);
} }
query query
unequal (ref_bind<T> r) const unequal (ref_bind<T> r) const
{ {
query q (table_, column_); query q (table_, column_);
q += "!="; q += "!=";
q.append<T, ID> (r); q.append<T, ID> (r, conversion_);
return q; return q;
} }
friend query friend query
operator!= (const query_column& c, const T& v) operator!= (const query_column& c, const T& v)
{ {
return c.unequal (v); return c.unequal (v);
} }
friend query friend query
skipping to change at line 665 skipping to change at line 680
less (const T& v) const less (const T& v) const
{ {
return less (val_bind<T> (v)); return less (val_bind<T> (v));
} }
query query
less (val_bind<T> v) const less (val_bind<T> v) const
{ {
query q (table_, column_); query q (table_, column_);
q += "<"; q += "<";
q.append<T, ID> (v); q.append<T, ID> (v, conversion_);
return q; return q;
} }
template <typename T2> template <typename T2>
query query
less (val_bind<T2> v) const less (val_bind<T2> v) const
{ {
copy_bind<T, T2> c (v.val); copy_bind<T, T2> c (v.val);
return less (c); return less (c);
} }
query query
less (ref_bind<T> r) const less (ref_bind<T> r) const
{ {
query q (table_, column_); query q (table_, column_);
q += "<"; q += "<";
q.append<T, ID> (r); q.append<T, ID> (r, conversion_);
return q; return q;
} }
friend query friend query
operator< (const query_column& c, const T& v) operator< (const query_column& c, const T& v)
{ {
return c.less (v); return c.less (v);
} }
friend query friend query
skipping to change at line 750 skipping to change at line 765
greater (const T& v) const greater (const T& v) const
{ {
return greater (val_bind<T> (v)); return greater (val_bind<T> (v));
} }
query query
greater (val_bind<T> v) const greater (val_bind<T> v) const
{ {
query q (table_, column_); query q (table_, column_);
q += ">"; q += ">";
q.append<T, ID> (v); q.append<T, ID> (v, conversion_);
return q; return q;
} }
template <typename T2> template <typename T2>
query query
greater (val_bind<T2> v) const greater (val_bind<T2> v) const
{ {
copy_bind<T, T2> c (v.val); copy_bind<T, T2> c (v.val);
return greater (c); return greater (c);
} }
query query
greater (ref_bind<T> r) const greater (ref_bind<T> r) const
{ {
query q (table_, column_); query q (table_, column_);
q += ">"; q += ">";
q.append<T, ID> (r); q.append<T, ID> (r, conversion_);
return q; return q;
} }
friend query friend query
operator> (const query_column& c, const T& v) operator> (const query_column& c, const T& v)
{ {
return c.greater (v); return c.greater (v);
} }
friend query friend query
skipping to change at line 835 skipping to change at line 850
less_equal (const T& v) const less_equal (const T& v) const
{ {
return less_equal (val_bind<T> (v)); return less_equal (val_bind<T> (v));
} }
query query
less_equal (val_bind<T> v) const less_equal (val_bind<T> v) const
{ {
query q (table_, column_); query q (table_, column_);
q += "<="; q += "<=";
q.append<T, ID> (v); q.append<T, ID> (v, conversion_);
return q; return q;
} }
template <typename T2> template <typename T2>
query query
less_equal (val_bind<T2> v) const less_equal (val_bind<T2> v) const
{ {
copy_bind<T, T2> c (v.val); copy_bind<T, T2> c (v.val);
return less_equal (c); return less_equal (c);
} }
query query
less_equal (ref_bind<T> r) const less_equal (ref_bind<T> r) const
{ {
query q (table_, column_); query q (table_, column_);
q += "<="; q += "<=";
q.append<T, ID> (r); q.append<T, ID> (r, conversion_);
return q; return q;
} }
friend query friend query
operator<= (const query_column& c, const T& v) operator<= (const query_column& c, const T& v)
{ {
return c.less_equal (v); return c.less_equal (v);
} }
friend query friend query
skipping to change at line 920 skipping to change at line 935
greater_equal (const T& v) const greater_equal (const T& v) const
{ {
return greater_equal (val_bind<T> (v)); return greater_equal (val_bind<T> (v));
} }
query query
greater_equal (val_bind<T> v) const greater_equal (val_bind<T> v) const
{ {
query q (table_, column_); query q (table_, column_);
q += ">="; q += ">=";
q.append<T, ID> (v); q.append<T, ID> (v, conversion_);
return q; return q;
} }
template <typename T2> template <typename T2>
query query
greater_equal (val_bind<T2> v) const greater_equal (val_bind<T2> v) const
{ {
copy_bind<T, T2> c (v.val); copy_bind<T, T2> c (v.val);
return greater_equal (c); return greater_equal (c);
} }
query query
greater_equal (ref_bind<T> r) const greater_equal (ref_bind<T> r) const
{ {
query q (table_, column_); query q (table_, column_);
q += ">="; q += ">=";
q.append<T, ID> (r); q.append<T, ID> (r, conversion_);
return q; return q;
} }
friend query friend query
operator>= (const query_column& c, const T& v) operator>= (const query_column& c, const T& v)
{ {
return c.greater_equal (v); return c.greater_equal (v);
} }
friend query friend query
skipping to change at line 1081 skipping to change at line 1096
query q (table_, column_); query q (table_, column_);
q += ">="; q += ">=";
q.append (c.table (), c.column ()); q.append (c.table (), c.column ());
return q; return q;
} }
private: private:
const char* table_; const char* table_;
const char* column_; const char* column_;
const char* conversion_;
}; };
// Provide operator+() for using columns to construct native // Provide operator+() for using columns to construct native
// query fragments (e.g., ORDER BY). // query fragments (e.g., ORDER BY).
// //
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
inline query inline query
operator+ (const query_column<T, ID>& c, const std::string& s) operator+ (const query_column<T, ID>& c, const std::string& s)
{ {
query q (c.table (), c.column ()); query q (c.table (), c.column ());
skipping to change at line 1153 skipping to change at line 1169
bind (sqlite::bind* b) bind (sqlite::bind* b)
{ {
b->type = sqlite::bind::integer; b->type = sqlite::bind::integer;
b->buffer = &image_; b->buffer = &image_;
} }
private: private:
void void
init (const T& v) init (const T& v)
{ {
bool dummy; bool is_null (false); // Can't be NULL.
value_traits<T, id_integer>::set_image (image_, dummy, v); value_traits<T, id_integer>::set_image (image_, is_null, v);
} }
private: private:
long long image_; long long image_;
}; };
// REAL // REAL
// //
template <typename T> template <typename T>
struct query_param_impl<T, id_real>: query_param struct query_param_impl<T, id_real>: query_param
skipping to change at line 1187 skipping to change at line 1203
bind (sqlite::bind* b) bind (sqlite::bind* b)
{ {
b->type = sqlite::bind::real; b->type = sqlite::bind::real;
b->buffer = &image_; b->buffer = &image_;
} }
private: private:
void void
init (const T& v) init (const T& v)
{ {
bool dummy; bool is_null (false); // Can't be NULL.
value_traits<T, id_real>::set_image (image_, dummy, v); value_traits<T, id_real>::set_image (image_, is_null, v);
} }
private: private:
double image_; double image_;
}; };
// TEXT // TEXT
// //
template <typename T> template <typename T>
struct query_param_impl<T, id_text>: query_param struct query_param_impl<T, id_text>: query_param
skipping to change at line 1212 skipping to change at line 1228
virtual bool virtual bool
init () init ()
{ {
return init (*static_cast<const T*> (value_)); return init (*static_cast<const T*> (value_));
} }
virtual void virtual void
bind (sqlite::bind* b) bind (sqlite::bind* b)
{ {
b->type = sqlite::bind::text; b->type = image_traits<T, id_text>::bind_value;
b->buffer = buffer_.data (); b->buffer = buffer_.data ();
b->size = &size_; b->size = &size_;
} }
private: private:
bool bool
init (const T& v) init (const T& v)
{ {
bool dummy; bool is_null (false); // Can't be NULL.
std::size_t cap (buffer_.capacity ()); std::size_t cap (buffer_.capacity ());
value_traits<T, id_text>::set_image (buffer_, size_, dummy, v); value_traits<T, id_text>::set_image (buffer_, size_, is_null, v);
return cap != buffer_.capacity (); return cap != buffer_.capacity ();
} }
private: private:
details::buffer buffer_; details::buffer buffer_;
std::size_t size_; std::size_t size_;
}; };
// BLOB // BLOB
// //
skipping to change at line 1258 skipping to change at line 1274
{ {
b->type = sqlite::bind::blob; b->type = sqlite::bind::blob;
b->buffer = buffer_.data (); b->buffer = buffer_.data ();
b->size = &size_; b->size = &size_;
} }
private: private:
bool bool
init (const T& v) init (const T& v)
{ {
bool dummy; bool is_null (false); // Can't be NULL.
std::size_t cap (buffer_.capacity ()); std::size_t cap (buffer_.capacity ());
value_traits<T, id_blob>::set_image (buffer_, size_, dummy, v); value_traits<T, id_blob>::set_image (buffer_, size_, is_null, v);
return cap != buffer_.capacity (); return cap != buffer_.capacity ();
} }
private: private:
details::buffer buffer_; details::buffer buffer_;
std::size_t size_; std::size_t size_;
}; };
} }
} }
// odb::query specialization for SQLite. // odb::query specialization for SQLite.
// //
namespace odb namespace odb
{ {
template <typename T> template <typename T>
class query<T, sqlite::query>: public query_selector<T>::type class query<T, sqlite::query>: public sqlite::query,
public query_selector<T>::columns_type
{ {
public: public:
// We don't define any typedefs here since they may clash with // We don't define any typedefs here since they may clash with
// column names defined by our base type. // column names defined by our base type.
// //
query () query ()
{ {
} }
explicit explicit
query (bool v) query (bool v)
: query_selector<T>::type (v) : sqlite::query (v)
{ {
} }
explicit explicit
query (const char* q) query (const char* q)
: query_selector<T>::type (q) : sqlite::query (q)
{ {
} }
explicit explicit
query (const std::string& q) query (const std::string& q)
: query_selector<T>::type (q) : sqlite::query (q)
{ {
} }
template <typename T2> template <typename T2>
explicit explicit
query (sqlite::val_bind<T2> v) query (sqlite::val_bind<T2> v)
: query_selector<T>::type (sqlite::query (v)) : sqlite::query (sqlite::query (v))
{ {
} }
template <typename T2> template <typename T2>
explicit explicit
query (sqlite::ref_bind<T2> r) query (sqlite::ref_bind<T2> r)
: query_selector<T>::type (sqlite::query (r)) : sqlite::query (sqlite::query (r))
{ {
} }
query (const sqlite::query& q) query (const sqlite::query& q)
: query_selector<T>::type (q) : sqlite::query (q)
{ {
} }
template <sqlite::database_type_id ID> template <sqlite::database_type_id ID>
query (const sqlite::query_column<bool, ID>& qc) query (const sqlite::query_column<bool, ID>& qc)
: query_selector<T>::type (qc) : sqlite::query (qc)
{ {
} }
}; };
} }
#include <odb/sqlite/query.ixx> #include <odb/sqlite/query.ixx>
#include <odb/sqlite/query.txx> #include <odb/sqlite/query.txx>
#include <odb/post.hxx> #include <odb/post.hxx>
 End of changes. 41 change blocks. 
40 lines changed or deleted 59 lines changed or added


 query.ixx   query.ixx 
skipping to change at line 23 skipping to change at line 23
} }
inline details::shared_ptr<query_params> query:: inline details::shared_ptr<query_params> query::
parameters () const parameters () const
{ {
return parameters_; return parameters_;
} }
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
inline void query:: inline void query::
append (val_bind<T> v) append (val_bind<T> v, const char* conv)
{ {
add ( add (
details::shared_ptr<query_param> ( details::shared_ptr<query_param> (
new (details::shared) query_param_impl<T, ID> (v))); new (details::shared) query_param_impl<T, ID> (v)),
conv);
} }
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
inline void query:: inline void query::
append (ref_bind<T> r) append (ref_bind<T> r, const char* conv)
{ {
add ( add (
details::shared_ptr<query_param> ( details::shared_ptr<query_param> (
new (details::shared) query_param_impl<T, ID> (r))); new (details::shared) query_param_impl<T, ID> (r)),
conv);
} }
} }
} }
 End of changes. 4 change blocks. 
4 lines changed or deleted 6 lines changed or added


 query.txx   query.txx 
skipping to change at line 22 skipping to change at line 22
template <database_type_id ID> template <database_type_id ID>
query:: query::
query (const query_column<bool, ID>& c) query (const query_column<bool, ID>& c)
: parameters_ (new (details::shared) query_params) : parameters_ (new (details::shared) query_params)
{ {
// Cannot use IS TRUE here since database type can be a non- // Cannot use IS TRUE here since database type can be a non-
// integral type. // integral type.
// //
append (c.table (), c.column ()); append (c.table (), c.column ());
append ("="); append ("=");
append<bool, ID> (val_bind<bool> (true)); append<bool, ID> (val_bind<bool> (true), c.conversion ());
} }
// query_column // query_column
// //
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
query query_column<T, ID>:: query query_column<T, ID>::
in (const T& v1, const T& v2) const in (const T& v1, const T& v2) const
{ {
query q (table_, column_); query q (table_, column_);
q += "IN ("; q += "IN (";
q.append<T, ID> (val_bind<T> (v1)); q.append<T, ID> (val_bind<T> (v1), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v2)); q.append<T, ID> (val_bind<T> (v2), conversion_);
q += ")"; q += ")";
return q; return q;
} }
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
query query_column<T, ID>:: query query_column<T, ID>::
in (const T& v1, const T& v2, const T& v3) const in (const T& v1, const T& v2, const T& v3) const
{ {
query q (table_, column_); query q (table_, column_);
q += "IN ("; q += "IN (";
q.append<T, ID> (val_bind<T> (v1)); q.append<T, ID> (val_bind<T> (v1), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v2)); q.append<T, ID> (val_bind<T> (v2), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v3)); q.append<T, ID> (val_bind<T> (v3), conversion_);
q += ")"; q += ")";
return q; return q;
} }
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
query query_column<T, ID>:: query query_column<T, ID>::
in (const T& v1, const T& v2, const T& v3, const T& v4) const in (const T& v1, const T& v2, const T& v3, const T& v4) const
{ {
query q (table_, column_); query q (table_, column_);
q += "IN ("; q += "IN (";
q.append<T, ID> (val_bind<T> (v1)); q.append<T, ID> (val_bind<T> (v1), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v2)); q.append<T, ID> (val_bind<T> (v2), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v3)); q.append<T, ID> (val_bind<T> (v3), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v4)); q.append<T, ID> (val_bind<T> (v4), conversion_);
q += ")"; q += ")";
return q; return q;
} }
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
query query_column<T, ID>:: query query_column<T, ID>::
in (const T& v1, const T& v2, const T& v3, const T& v4, const T& v5) co nst in (const T& v1, const T& v2, const T& v3, const T& v4, const T& v5) co nst
{ {
query q (table_, column_); query q (table_, column_);
q += "IN ("; q += "IN (";
q.append<T, ID> (val_bind<T> (v1)); q.append<T, ID> (val_bind<T> (v1), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v2)); q.append<T, ID> (val_bind<T> (v2), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v3)); q.append<T, ID> (val_bind<T> (v3), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v4)); q.append<T, ID> (val_bind<T> (v4), conversion_);
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (v5)); q.append<T, ID> (val_bind<T> (v5), conversion_);
q += ")"; q += ")";
return q; return q;
} }
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
template <typename I> template <typename I>
query query_column<T, ID>:: query query_column<T, ID>::
in_range (I begin, I end) const in_range (I begin, I end) const
{ {
query q (table_, column_); query q (table_, column_);
q += "IN ("; q += "IN (";
for (I i (begin); i != end; ++i) for (I i (begin); i != end; ++i)
{ {
if (i != begin) if (i != begin)
q += ","; q += ",";
q.append<T, ID> (val_bind<T> (*i)); q.append<T, ID> (val_bind<T> (*i), conversion_);
} }
q += ")"; q += ")";
return q; return q;
} }
} }
} }
 End of changes. 16 change blocks. 
16 lines changed or deleted 16 lines changed or added


 sqlite-types.hxx   sqlite-types.hxx 
skipping to change at line 25 skipping to change at line 25
{ {
// The SQLite parameter/result binding. This data structures is modelle d // The SQLite parameter/result binding. This data structures is modelle d
// after MYSQL_BIND from MySQL. // after MYSQL_BIND from MySQL.
// //
struct bind struct bind
{ {
enum buffer_type enum buffer_type
{ {
integer, // Buffer is long long; size, capacity, truncated are unus ed. integer, // Buffer is long long; size, capacity, truncated are unus ed.
real, // Buffer is double; size, capacity, truncated are unused. real, // Buffer is double; size, capacity, truncated are unused.
text, // Buffer is a char array. text, // Buffer is a UTF-8 char array.
text16, // Buffer is a UTF-16 2-byte char array (sizes in bytes).
blob // Buffer is a char array. blob // Buffer is a char array.
}; };
buffer_type type; buffer_type type;
void* buffer; void* buffer;
std::size_t* size; std::size_t* size;
std::size_t capacity; std::size_t capacity;
bool* is_null; bool* is_null;
bool* truncated; bool* truncated;
}; };
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 traits.hxx   traits.hxx 
// file : odb/sqlite/traits.hxx // file : odb/sqlite/traits.hxx
// copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC // copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file // license : GNU GPL v2; see accompanying LICENSE file
#ifndef ODB_SQLITE_TRAITS_HXX #ifndef ODB_SQLITE_TRAITS_HXX
#define ODB_SQLITE_TRAITS_HXX #define ODB_SQLITE_TRAITS_HXX
#include <odb/pre.hxx> #include <odb/pre.hxx>
#include <odb/details/config.hxx> // ODB_CXX11
#include <string> #include <string>
#include <vector> #include <vector>
#include <limits> // std::numeric_limits
#include <cstddef> // std::size_t #include <cstddef> // std::size_t
#include <cstring> // std::memcpy, std::memset, std::strlen #include <cstring> // std::memcpy, std::memset, std::strlen
#ifdef ODB_CXX11
# include <array>
#endif
#include <odb/traits.hxx> #include <odb/traits.hxx>
#include <odb/wrapper-traits.hxx> #include <odb/wrapper-traits.hxx>
#include <odb/details/buffer.hxx> #include <odb/details/buffer.hxx>
#include <odb/details/wrapper-p.hxx> #include <odb/details/wrapper-p.hxx>
#include <odb/sqlite/version.hxx> #include <odb/sqlite/version.hxx>
#include <odb/sqlite/sqlite-types.hxx>
#include <odb/sqlite/details/export.hxx> #include <odb/sqlite/details/export.hxx>
namespace odb namespace odb
{ {
namespace sqlite namespace sqlite
{ {
enum database_type_id enum database_type_id
{ {
id_integer, id_integer,
id_real, id_real,
id_text, id_text,
id_blob id_blob
}; };
// //
// image_traits // image_traits
// //
template <database_type_id> template <typename T, database_type_id>
struct image_traits; struct image_traits;
template <> template <typename T>
struct image_traits<id_integer> {typedef long long image_type;}; struct image_traits<T, id_integer> {typedef long long image_type;};
template <> template <typename T>
struct image_traits<id_real> {typedef double image_type;}; struct image_traits<T, id_real> {typedef double image_type;};
template <> template <typename T>
struct image_traits<id_text> {typedef details::buffer image_type;}; struct image_traits<T, id_text>
{
typedef details::buffer image_type;
template <> // By default the text is in UTF-8.
struct image_traits<id_blob> {typedef details::buffer image_type;}; //
static const bind::buffer_type bind_value = bind::text;
};
template <typename T>
struct image_traits<T, id_blob> {typedef details::buffer image_type;};
// //
// value_traits // value_traits
// //
template <typename W, database_type_id, bool null_handler> template <typename W, database_type_id, bool null_handler>
struct wrapped_value_traits; struct wrapped_value_traits;
template <typename T, database_type_id> template <typename T, database_type_id>
struct default_value_traits; struct default_value_traits;
skipping to change at line 99 skipping to change at line 114
// of the set_value() and set_image() functions. // of the set_value() and set_image() functions.
// //
template <typename W, database_type_id ID> template <typename W, database_type_id ID>
struct wrapped_value_traits<W, ID, false> struct wrapped_value_traits<W, ID, false>
{ {
typedef wrapper_traits<W> wtraits; typedef wrapper_traits<W> wtraits;
typedef typename wtraits::unrestricted_wrapped_type wrapped_type; typedef typename wtraits::unrestricted_wrapped_type wrapped_type;
typedef W value_type; typedef W value_type;
typedef wrapped_type query_type; typedef wrapped_type query_type;
typedef typename image_traits<ID>::image_type image_type; typedef typename image_traits<wrapped_type, ID>::image_type image_typ e;
typedef value_traits<wrapped_type, ID> vtraits; typedef value_traits<wrapped_type, ID> vtraits;
static void static void
set_value (W& v, const image_type& i, bool is_null) set_value (W& v, const image_type& i, bool is_null)
{ {
vtraits::set_value (wtraits::set_ref (v), i, is_null); vtraits::set_value (wtraits::set_ref (v), i, is_null);
} }
static void static void
skipping to change at line 138 skipping to change at line 153
}; };
template <typename W, database_type_id ID> template <typename W, database_type_id ID>
struct wrapped_value_traits<W, ID, true> struct wrapped_value_traits<W, ID, true>
{ {
typedef wrapper_traits<W> wtraits; typedef wrapper_traits<W> wtraits;
typedef typename wtraits::unrestricted_wrapped_type wrapped_type; typedef typename wtraits::unrestricted_wrapped_type wrapped_type;
typedef W value_type; typedef W value_type;
typedef wrapped_type query_type; typedef wrapped_type query_type;
typedef typename image_traits<ID>::image_type image_type; typedef typename image_traits<wrapped_type, ID>::image_type image_typ e;
typedef value_traits<wrapped_type, ID> vtraits; typedef value_traits<wrapped_type, ID> vtraits;
static void static void
set_value (W& v, const image_type& i, bool is_null) set_value (W& v, const image_type& i, bool is_null)
{ {
if (is_null) if (is_null)
wtraits::set_null (v); wtraits::set_null (v);
else else
vtraits::set_value (wtraits::set_ref (v), i, is_null); vtraits::set_value (wtraits::set_ref (v), i, is_null);
skipping to change at line 186 skipping to change at line 201
if (!is_null) if (!is_null)
vtraits::set_image (b, n, is_null, wtraits::get_ref (v)); vtraits::set_image (b, n, is_null, wtraits::get_ref (v));
} }
}; };
template <typename T, database_type_id ID> template <typename T, database_type_id ID>
struct default_value_traits struct default_value_traits
{ {
typedef T value_type; typedef T value_type;
typedef T query_type; typedef T query_type;
typedef typename image_traits<ID>::image_type image_type; typedef typename image_traits<T, ID>::image_type image_type;
static void static void
set_value (T& v, const image_type& i, bool is_null) set_value (T& v, const image_type& i, bool is_null)
{ {
if (!is_null) if (!is_null)
v = T (i); v = T (i);
else else
v = T (); v = T ();
} }
static void static void
set_image (image_type& i, bool& is_null, T v) set_image (image_type& i, bool& is_null, T v)
{ {
is_null = false; is_null = false;
i = image_type (v); i = image_type (v);
} }
}; };
// Float & double specialization. SQLite converts NaNs to NULLs so
// we convert NULLs to NaNs for consistency.
//
template <typename T>
struct real_value_traits
{
typedef T value_type;
typedef T query_type;
typedef double image_type;
static void
set_value (T& v, double i, bool is_null)
{
if (!is_null)
v = T (i);
else
v = std::numeric_limits<T>::quiet_NaN ();
}
static void
set_image (double& i, bool& is_null, T v)
{
is_null = false;
i = image_type (v);
}
};
template <>
struct LIBODB_SQLITE_EXPORT default_value_traits<float, id_real>:
real_value_traits<float>
{
};
template <>
struct LIBODB_SQLITE_EXPORT default_value_traits<double, id_real>:
real_value_traits<double>
{
};
// std::string specialization. // std::string specialization.
// //
template <> template <>
struct LIBODB_SQLITE_EXPORT default_value_traits<std::string, id_text> struct LIBODB_SQLITE_EXPORT default_value_traits<std::string, id_text>
{ {
typedef std::string value_type; typedef std::string value_type;
typedef std::string query_type; typedef std::string query_type;
typedef details::buffer image_type; typedef details::buffer image_type;
static void static void
skipping to change at line 258 skipping to change at line 312
bool& is_null, bool& is_null,
const char*); const char*);
}; };
template <> template <>
struct LIBODB_SQLITE_EXPORT default_value_traits<const char*, id_text>: struct LIBODB_SQLITE_EXPORT default_value_traits<const char*, id_text>:
c_string_value_traits c_string_value_traits
{ {
}; };
template <std::size_t n> template <std::size_t N>
struct default_value_traits<char[n], id_text>: c_string_value_traits struct default_value_traits<char[N], id_text>: c_string_value_traits
{
};
template <std::size_t N>
struct default_value_traits<const char[N], id_text>: c_string_value_tra
its
{
};
#ifdef _WIN32
// std::wstring specialization. Using UTF-16 binding.
//
template <>
struct image_traits<std::wstring, id_text>
{
typedef details::buffer image_type;
static const bind::buffer_type bind_value = bind::text16;
};
template <>
struct LIBODB_SQLITE_EXPORT default_value_traits<std::wstring, id_text>
{
typedef std::wstring value_type;
typedef std::wstring query_type;
typedef details::buffer image_type;
static void
set_value (std::wstring& v,
const details::buffer& b,
std::size_t n,
bool is_null)
{
if (!is_null)
v.assign (reinterpret_cast<const wchar_t*> (b.data ()), n / 2);
else
v.erase ();
}
static void
set_image (details::buffer&,
std::size_t& n,
bool& is_null,
const std::wstring&);
};
// const wchar_t* specialization
//
struct c_wstring_image_traits
{
typedef details::buffer image_type;
static const bind::buffer_type bind_value = bind::text16;
};
struct LIBODB_SQLITE_EXPORT c_wstring_value_traits
{ {
typedef const wchar_t* value_type;
typedef const wchar_t* query_type;
typedef details::buffer image_type;
static void
set_image (details::buffer&,
std::size_t& n,
bool& is_null,
const wchar_t*);
}; };
template <std::size_t n> template <>
struct default_value_traits<const char[n], id_text>: c_string_value_tra struct image_traits<const wchar_t*, id_text>: c_wstring_image_traits {}
its ;
template <>
struct LIBODB_SQLITE_EXPORT default_value_traits<const wchar_t*, id_tex
t>:
c_wstring_value_traits
{ {
}; };
template <std::size_t N>
struct image_traits<wchar_t[N], id_text>: c_wstring_image_traits {};
template <std::size_t N>
struct default_value_traits<wchar_t[N], id_text>:
c_wstring_value_traits
{
};
template <std::size_t N>
struct image_traits<const wchar_t[N], id_text>: c_wstring_image_traits
{};
template <std::size_t N>
struct default_value_traits<const wchar_t[N], id_text>:
c_wstring_value_traits
{
};
#endif // _WIN32
// std::vector<char> (buffer) specialization. // std::vector<char> (buffer) specialization.
// //
template <> template <>
struct LIBODB_SQLITE_EXPORT default_value_traits< struct LIBODB_SQLITE_EXPORT default_value_traits<
std::vector<char>, id_blob> std::vector<char>, id_blob>
{ {
public: public:
typedef std::vector<char> value_type; typedef std::vector<char> value_type;
typedef std::vector<char> query_type; typedef std::vector<char> query_type;
typedef details::buffer image_type; typedef details::buffer image_type;
skipping to change at line 332 skipping to change at line 471
v.clear (); v.clear ();
} }
static void static void
set_image (details::buffer&, set_image (details::buffer&,
std::size_t& n, std::size_t& n,
bool& is_null, bool& is_null,
const value_type&); const value_type&);
}; };
// char[n] (buffer) specialization. // char[N] (buffer) specialization.
// //
template <std::size_t N> template <std::size_t N>
struct default_value_traits<char[N], id_blob> struct default_value_traits<char[N], id_blob>
{ {
public: public:
typedef char* value_type; typedef char* value_type;
typedef const char* query_type; typedef const char* query_type;
typedef details::buffer image_type; typedef details::buffer image_type;
static void static void
skipping to change at line 370 skipping to change at line 509
is_null = false; is_null = false;
n = N; n = N;
if (n > b.capacity ()) if (n > b.capacity ())
b.capacity (n); b.capacity (n);
std::memcpy (b.data (), v, n); std::memcpy (b.data (), v, n);
} }
}; };
// unsigned char[n] (buffer) specialization. // unsigned char[N] (buffer) specialization.
// //
template <std::size_t N> template <std::size_t N>
struct default_value_traits<unsigned char[N], id_blob> struct default_value_traits<unsigned char[N], id_blob>
{ {
public: public:
typedef unsigned char* value_type; typedef unsigned char* value_type;
typedef const unsigned char* query_type; typedef const unsigned char* query_type;
typedef details::buffer image_type; typedef details::buffer image_type;
static void static void
skipping to change at line 408 skipping to change at line 547
is_null = false; is_null = false;
n = N; n = N;
if (n > b.capacity ()) if (n > b.capacity ())
b.capacity (n); b.capacity (n);
std::memcpy (b.data (), v, n); std::memcpy (b.data (), v, n);
} }
}; };
#ifdef ODB_CXX11
// std::array<char, N> (buffer) specialization.
//
template <std::size_t N>
struct default_value_traits<std::array<char, N>, id_blob>
{
public:
typedef std::array<char, N> value_type;
typedef value_type query_type;
typedef details::buffer image_type;
static void
set_value (value_type& v,
const details::buffer& b,
std::size_t n,
bool is_null)
{
if (!is_null)
std::memcpy (v.data (), b.data (), (n < N ? n : N));
else
std::memset (v.data (), 0, N);
}
static void
set_image (details::buffer& b,
std::size_t& n,
bool& is_null,
const value_type& v)
{
is_null = false;
n = N;
if (n > b.capacity ())
b.capacity (n);
std::memcpy (b.data (), v.data (), n);
}
};
// std::array<unsigned char, N> (buffer) specialization.
//
template <std::size_t N>
struct default_value_traits<std::array<unsigned char, N>, id_blob>
{
public:
typedef std::array<unsigned char, N> value_type;
typedef value_type query_type;
typedef details::buffer image_type;
static void
set_value (value_type& v,
const details::buffer& b,
std::size_t n,
bool is_null)
{
if (!is_null)
std::memcpy (v.data (), b.data (), (n < N ? n : N));
else
std::memset (v.data (), 0, N);
}
static void
set_image (details::buffer& b,
std::size_t& n,
bool& is_null,
const value_type& v)
{
is_null = false;
n = N;
if (n > b.capacity ())
b.capacity (n);
std::memcpy (b.data (), v.data (), n);
}
};
#endif
// //
// type_traits // type_traits
// //
template <typename T> template <typename T>
struct default_type_traits; struct default_type_traits;
template <typename T> template <typename T>
class type_traits: public default_type_traits<T> class type_traits: public default_type_traits<T>
{ {
skipping to change at line 502 skipping to change at line 719
{ {
static const database_type_id db_type_id = id_real; static const database_type_id db_type_id = id_real;
}; };
template <> template <>
struct default_type_traits<double> struct default_type_traits<double>
{ {
static const database_type_id db_type_id = id_real; static const database_type_id db_type_id = id_real;
}; };
// String type. // String types.
// //
template <> template <>
struct default_type_traits<std::string> struct default_type_traits<std::string>
{ {
static const database_type_id db_type_id = id_text; static const database_type_id db_type_id = id_text;
}; };
template <> template <>
struct default_type_traits<const char*> struct default_type_traits<const char*>
{ {
static const database_type_id db_type_id = id_text; static const database_type_id db_type_id = id_text;
}; };
template <std::size_t n> template <std::size_t N>
struct default_type_traits<char[n]> struct default_type_traits<char[N]>
{ {
static const database_type_id db_type_id = id_text; static const database_type_id db_type_id = id_text;
}; };
template <std::size_t n> template <std::size_t N>
struct default_type_traits<const char[n]> struct default_type_traits<const char[N]>
{ {
static const database_type_id db_type_id = id_text; static const database_type_id db_type_id = id_text;
}; };
// Binary types.
//
template <>
struct default_type_traits<std::vector<char> >
{
static const database_type_id db_type_id = id_blob;
};
template <>
struct default_type_traits<std::vector<unsigned char> >
{
static const database_type_id db_type_id = id_blob;
};
#ifdef ODB_CXX11
template <std::size_t N>
struct default_type_traits<std::array<char, N> >
{
static const database_type_id db_type_id = id_blob;
};
template <std::size_t N>
struct default_type_traits<std::array<unsigned char, N> >
{
static const database_type_id db_type_id = id_blob;
};
#endif
} }
} }
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_SQLITE_TRAITS_HXX #endif // ODB_SQLITE_TRAITS_HXX
 End of changes. 24 change blocks. 
24 lines changed or deleted 272 lines changed or added


 version.hxx   version.hxx 
skipping to change at line 31 skipping to change at line 31
// Version AABBCCDD // Version AABBCCDD
// 2.0.0 02000000 // 2.0.0 02000000
// 2.1.0 02010000 // 2.1.0 02010000
// 2.1.1 02010100 // 2.1.1 02010100
// 2.2.0.a1 02019901 // 2.2.0.a1 02019901
// 3.0.0.b2 02999952 // 3.0.0.b2 02999952
// //
// Check that we have compatible ODB version. // Check that we have compatible ODB version.
// //
#if ODB_VERSION != 20000 #if ODB_VERSION != 20100
# error incompatible odb interface version detected # error incompatible odb interface version detected
#endif #endif
// libodb-sqlite version: odb interface version plus the bugfix // libodb-sqlite version: odb interface version plus the bugfix
// version. // version.
// //
#define LIBODB_SQLITE_VERSION 2000100 #define LIBODB_SQLITE_VERSION 2010000
#define LIBODB_SQLITE_VERSION_STR "2.0.1" #define LIBODB_SQLITE_VERSION_STR "2.1.0"
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_SQLITE_VERSION_HXX #endif // ODB_SQLITE_VERSION_HXX
 End of changes. 2 change blocks. 
3 lines changed or deleted 3 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/