common.hpp

Go to the documentation of this file.

#ifndef TIP_DB_PG_COMMON_HPP_
#define TIP_DB_PG_COMMON_HPP_

#include <string>
#include <iosfwd>
#include <vector>
#include <functional>
#include <memory>
#include <map>
#include <boost/integer.hpp>
#include <boost/optional.hpp>

#include <tip/util/streambuf.hpp>
#include <tip/db/pg/pg_types.hpp>

namespace tip {
namespace db {
namespace pg {

typedef boost::int_t<16>::exact     smallint;
typedef boost::uint_t<16>::exact    usmallint;
typedef boost::int_t<32>::exact     integer;
typedef boost::uint_t<32>::exact    uinteger;
typedef boost::int_t<64>::exact     bigint;
typedef boost::uint_t<64>::exact    ubigint;

const integer PROTOCOL_VERSION = (3 << 16); // 3.0

typedef char byte;

template < typename T >
using nullable = boost::optional<T>;

struct bytea {
    typedef std::vector<byte> container_type;   
    container_type data;    
};

typedef tip::util::input_iterator_buffer field_buffer;

struct dbalias {
    std::string value;

    void
    swap(std::string& rhs) /* no_throw */
    {
        value.swap(rhs);
    }

    operator std::string () { return value; }

    bool
    operator == (dbalias const& rhs) const
    {
        return value == rhs.value;
    }
    bool
    operator != (dbalias const& rhs) const
    {
        return !(*this == rhs);
    }

    bool
    operator < (dbalias const& rhs) const
    {
        return value < rhs.value;
    }
};

inline bool
operator == (dbalias const& lhs, std::string const& rhs)
{
    return lhs.value == rhs;
}

std::ostream&
operator << (std::ostream& out, dbalias const&);

struct connection_options {
    dbalias alias;          
    std::string schema;     
    std::string uri;        
    std::string database;   
    std::string user;       
    std::string password;   
    void
    generate_alias();
    static connection_options
    parse(std::string const&);
};

enum protocol_data_format {
    TEXT_DATA_FORMAT = 0, 
    BINARY_DATA_FORMAT = 1
};

struct field_description {
    std::string             name;
    integer                 table_oid;
    smallint                attribute_number;
    oids::type::oid_type    type_oid;
    smallint                type_size;
    integer                 type_mod;
    protocol_data_format    format_code;
    integer                 max_size;           
};
typedef std::vector< field_description > row_description_type;


class resultset;
class transaction;
class basic_connection;
namespace error {
class db_error;
class connection_error;
class query_error;
} // namespace error


typedef std::shared_ptr<transaction> transaction_ptr;
typedef std::shared_ptr<basic_connection> connection_ptr;

typedef std::map< std::string, std::string > client_options_type;
typedef std::vector< oids::type::oid_type > type_oid_sequence;

typedef std::function< void () > simple_callback;
typedef std::function< void (error::db_error const&) > error_callback;
typedef std::function< void (transaction_ptr) > transaction_callback;

typedef std::function< void (transaction_ptr, resultset, bool) > query_result_callback;
typedef std::function< void (error::query_error const&) > query_error_callback;

namespace options {

const std::string HOST              = "host";
const std::string PORT              = "port";
const std::string USER              = "user";
const std::string DATABASE          = "database";
const std::string CLIENT_ENCODING   = "client_encoding";
const std::string APPLICATION_NAME  = "application_name";

}  // namespace options

}  // namespace pg
}  // namespace db
}  // namespace tip

tip::db::pg::dbalias
operator"" _db(const char*, size_t n);

tip::db::pg::connection_options
operator"" _pg(const char*, size_t);

#endif /* TIP_DB_PG_COMMON_HPP_ */