/usr/include/mysql++/field.h is in libmysql++-dev 3.2.1+pristine-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | /// \file field.h
/// \brief Declares the Field and Fields classes.
/***********************************************************************
Copyright (c) 2007 by Educational Technology Resources, Inc.
Others may also hold copyrights on code in this file. See the
CREDITS.txt file in the top directory of the distribution for details.
This file is part of MySQL++.
MySQL++ is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
MySQL++ is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
License for more details.
You should have received a copy of the GNU Lesser General Public
License along with MySQL++; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
USA
***********************************************************************/
#if !defined(MYSQLPP_FIELD_H)
#define MYSQLPP_FIELD_H
#include "common.h"
#include "type_info.h"
#include <vector>
namespace mysqlpp {
/// \brief Class to hold information about a SQL field
///
/// This is a cut-down version of MYSQL_FIELD, using MySQL++ and generic
/// C++ types instead of the C types it uses, and hiding all fields
/// behind accessors. It leaves out data members we have decided aren't
/// very useful. Given a good argument, we're willing to mirror more of
/// the fields; we just don't want to mirror the underlying structure
/// slavishly for no benefit.
class Field
{
public:
/// \brief Create empty object
Field() :
length_(0),
max_length_(0),
flags_(0)
{
}
/// \brief Create object from C API field structure
Field(const MYSQL_FIELD* pf) :
name_(pf->name),
table_(pf->table),
#if MYSQL_VERSION_ID > 40000 // only in 4.0 +
db_(pf->db),
#endif
type_(pf->type, (pf->flags & UNSIGNED_FLAG) != 0,
(pf->flags & NOT_NULL_FLAG) == 0),
length_(pf->length),
max_length_(pf->max_length),
flags_(pf->flags)
{
}
/// \brief Create object as a copy of another Field
Field(const Field& other) :
name_(other.name_),
table_(other.table_),
db_(other.db_),
type_(other.type_),
length_(other.length_),
max_length_(other.max_length_),
flags_(other.flags_)
{
}
/// \brief Returns true if field auto-increments
bool auto_increment() const { return flags_ & AUTO_INCREMENT_FLAG; }
/// \brief Returns true if field is of some binary type
bool binary_type() const { return flags_ & BINARY_FLAG; }
/// \brief Returns true if field is of some BLOB type
bool blob_type() const { return flags_ & BLOB_FLAG; }
/// \brief Return the name of the database the field comes from
const char* db() const { return db_.c_str(); }
/// \brief Returns true if field is of an enumerated value type
bool enumeration() const { return flags_ & ENUM_FLAG; }
/// \brief Return the creation size of the field
///
/// This is the number of bytes the field can hold, not how much is
/// actually stored in the field on any particular row.
size_t length() const { return length_; }
/// \brief Return the maximum number of bytes stored in this field
/// in any of the rows in the result set we were created from.
size_t max_length() const { return max_length_; }
/// \brief Returns true if field is part of a key
bool multiple_key() const { return flags_ & MULTIPLE_KEY_FLAG; }
/// \brief Return the field's name
const char* name() const { return name_.c_str(); }
#if defined(NO_DEFAULT_VALUE_FLAG)
/// \brief Returns true if field has no default value
bool no_default() const { return flags_ & NO_DEFAULT_VALUE_FLAG; }
#endif
/// \brief Returns true if field is part of a primary key
bool primary_key() const { return flags_ & PRI_KEY_FLAG; }
/// \brief Returns true if field is of some 'set' type
bool set_type() const { return flags_ & SET_FLAG; }
/// \brief Return the name of the table the field comes from
const char* table() const { return table_.c_str(); }
/// \brief Returns true if field's type is timestamp
bool timestamp() const { return flags_ & TIMESTAMP_FLAG; }
/// \brief Return information about the field's type
const mysql_type_info& type() const { return type_; }
/// \brief Returns true if field is part of a unique key
bool unique_key() const { return flags_ & UNIQUE_KEY_FLAG; }
/// \brief Returns true if field has the zerofill attribute
bool zerofill() const { return flags_ & ZEROFILL_FLAG; }
private:
std::string name_; ///< the field's name
std::string table_; ///< name of table field comes from
std::string db_; ///< name of database field comes from
mysql_type_info type_; ///< info about the field's type
size_t length_; ///< creation size of column
size_t max_length_; ///< size of largest item in column in result set
unsigned int flags_; ///< DB engine-specific set of bit flags
};
/// \brief The list-of-Fields type
typedef std::vector<Field> Fields;
} // end namespace mysqlpp
#endif // !defined(MYSQLPP_FIELD_H)
|