抛弃GdCpp*.dll/pdb历史重新建库。libhv和Sqlite的dll保留
This commit is contained in:
Zhang Jianjun
335
include/CSQLite/CSQLiteColumn.h
Normal file
335
include/CSQLite/CSQLiteColumn.h
Normal file
@@ -0,0 +1,335 @@
|
||||
/**
|
||||
* @file CSQLiteColumn.h
|
||||
* @ingroup CSQLite
|
||||
* @brief Encapsulation of a Column in a row of the result pointed by the prepared SQLite::Statement.
|
||||
*
|
||||
* Copyright (c) 2012-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
|
||||
*
|
||||
* Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
|
||||
* or copy at http://opensource.org/licenses/MIT)
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include "_Statement.h"
|
||||
#include <climits> // For INT_MAX
|
||||
#include "GdCPP_Exports.h"
|
||||
|
||||
/**
|
||||
* @brief Encapsulation of a Column in a row of the result pointed by the prepared Statement.
|
||||
*
|
||||
* A Column is a particular field of SQLite data in the current row of result
|
||||
* of the Statement : it points to a single cell.
|
||||
*
|
||||
* Its value can be expressed as a text, and, when applicable, as a numeric
|
||||
* (integer or floating point) or a binary blob.
|
||||
*
|
||||
* Thread-safety: a Column object shall not be shared by multiple threads, because :
|
||||
* 1) in the SQLite "Thread Safe" mode, "SQLite can be safely used by multiple threads
|
||||
* provided that no single database connection is used simultaneously in two or more threads."
|
||||
* 2) the SQLite "Serialized" mode is not supported by SQLiteC++,
|
||||
* because of the way it shares the underling SQLite precompiled statement
|
||||
* in a custom shared pointer (See the inner class "Statement::Ptr").
|
||||
*/
|
||||
class GDCPP_API CSQLiteColumn
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* @brief Encapsulation of a Column in a Row of the result.
|
||||
*
|
||||
* @param[in] aStmtPtr Shared pointer to the prepared SQLite Statement Object.
|
||||
* @param[in] aIndex Index of the column in the row of result, starting at 0
|
||||
*/
|
||||
CSQLiteColumn(_StatementPtr& aStmtPtr, int aIndex) noexcept: // nothrow
|
||||
mStmtPtr(aStmtPtr),
|
||||
mIndex(aIndex)
|
||||
{
|
||||
}
|
||||
/// Finalize and unregister the SQL query from the SQLite Database Connection.
|
||||
~CSQLiteColumn()
|
||||
{
|
||||
// the finalization will be done by the destructor of the last shared pointer
|
||||
}
|
||||
|
||||
// default copy constructor and assignment operator are perfectly suited :
|
||||
// they copy the Statement::Ptr which in turn increments the reference counter.
|
||||
|
||||
/// Make clang happy by explicitly implementing the copy-constructor:
|
||||
CSQLiteColumn(const CSQLiteColumn & aOther) :
|
||||
mStmtPtr(aOther.mStmtPtr),
|
||||
mIndex(aOther.mIndex)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return a pointer to the named assigned to this result column (potentially aliased)
|
||||
*
|
||||
* @see getOriginName() to get original column name (not aliased)
|
||||
*/
|
||||
const char* getName() const noexcept // nothrow
|
||||
{
|
||||
return sqlite3_column_name(*mStmtPtr, mIndex);
|
||||
}
|
||||
|
||||
#ifdef SQLITE_ENABLE_COLUMN_METADATA
|
||||
/**
|
||||
* @brief Return a pointer to the table column name that is the origin of this result column
|
||||
*
|
||||
* Require definition of the SQLITE_ENABLE_COLUMN_METADATA preprocessor macro :
|
||||
* - when building the SQLite library itself (which is the case for the Debian libsqlite3 binary for instance),
|
||||
* - and also when compiling this wrapper.
|
||||
*/
|
||||
const char* getOriginName() const noexcept // nothrow
|
||||
{
|
||||
return sqlite3_column_origin_name(mStmtPtr, mIndex);
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Return the integer value of the column specified by its index starting at 0
|
||||
inline int getInt() const noexcept // nothrow
|
||||
{
|
||||
return sqlite3_column_int(*mStmtPtr, mIndex);
|
||||
}
|
||||
/// Return the 32bits unsigned integer value of the column specified by its index starting at 0
|
||||
/// (note that SQLite3 does not support unsigned 64bits).
|
||||
inline unsigned getUInt() const noexcept // nothrow
|
||||
{
|
||||
return static_cast<unsigned>(getInt());
|
||||
}
|
||||
/// Return the 64bits integer value of the column specified by its index starting at 0
|
||||
/// (note that SQLite3 does not support unsigned 64bits).
|
||||
inline long long getInt64() const noexcept // nothrow
|
||||
{
|
||||
return sqlite3_column_int64(*mStmtPtr, mIndex);
|
||||
}
|
||||
/// Return the double (64bits float) value of the column
|
||||
inline double getDouble() const noexcept // nothrow
|
||||
{
|
||||
return sqlite3_column_double(*mStmtPtr, mIndex);
|
||||
}
|
||||
/**
|
||||
* @brief Return a pointer to the text value (NULL terminated string) of the column.
|
||||
*
|
||||
* @warning The value pointed at is only valid while the statement is valid (ie. not finalized),
|
||||
* thus you must copy it before using it beyond its scope (to a std::string for instance).
|
||||
*/
|
||||
inline const char* getText(const char* apDefaultValue = "") const noexcept // nothrow
|
||||
{
|
||||
const char* pText = reinterpret_cast<const char*>(sqlite3_column_text(*mStmtPtr, mIndex));
|
||||
return (pText?pText:apDefaultValue);
|
||||
}
|
||||
/**
|
||||
* @brief Return a pointer to the binary blob value of the column.
|
||||
*
|
||||
* @warning The value pointed at is only valid while the statement is valid (ie. not finalized),
|
||||
* thus you must copy it before using it beyond its scope (to a std::string for instance).
|
||||
*/
|
||||
inline const void* getBlob() const noexcept // nothrow
|
||||
{
|
||||
return sqlite3_column_blob(*mStmtPtr, mIndex);
|
||||
}
|
||||
// /**
|
||||
// * @brief Return a std::string for a TEXT or BLOB column.
|
||||
// *
|
||||
// * Note this correctly handles strings that contain null bytes.
|
||||
// */
|
||||
// std::string getString() const;
|
||||
|
||||
/**
|
||||
* @brief Return the type of the value of the column
|
||||
*
|
||||
* Return either SQLite::INTEGER, SQLite::FLOAT, SQLite::TEXT, SQLite::BLOB, or SQLite::Null.
|
||||
*
|
||||
* @warning After a type conversion (by a call to a getXxx on a Column of a Yyy type),
|
||||
* the value returned by sqlite3_column_type() is undefined.
|
||||
*/
|
||||
inline int getType() const noexcept // nothrow
|
||||
{
|
||||
return sqlite3_column_type(*mStmtPtr, mIndex);
|
||||
}
|
||||
|
||||
|
||||
/// Test if the column is an integer type value (meaningful only before any conversion)
|
||||
inline bool isInteger() const noexcept // nothrow
|
||||
{
|
||||
return (SQLITE_INTEGER == getType());
|
||||
}
|
||||
/// Test if the column is a floating point type value (meaningful only before any conversion)
|
||||
inline bool isFloat() const noexcept // nothrow
|
||||
{
|
||||
return (SQLITE_FLOAT == getType());
|
||||
}
|
||||
/// Test if the column is a text type value (meaningful only before any conversion)
|
||||
inline bool isText() const noexcept // nothrow
|
||||
{
|
||||
return (SQLITE_TEXT == getType());
|
||||
}
|
||||
/// Test if the column is a binary blob type value (meaningful only before any conversion)
|
||||
inline bool isBlob() const noexcept // nothrow
|
||||
{
|
||||
return (SQLITE_BLOB == getType());
|
||||
}
|
||||
/// Test if the column is NULL (meaningful only before any conversion)
|
||||
inline bool isNull() const noexcept // nothrow
|
||||
{
|
||||
return (SQLITE_NULL == getType());
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return the number of bytes used by the text (or blob) value of the column
|
||||
*
|
||||
* Return either :
|
||||
* - size in bytes (not in characters) of the string returned by getText() without the '\0' terminator
|
||||
* - size in bytes of the string representation of the numerical value (integer or double)
|
||||
* - size in bytes of the binary blob returned by getBlob()
|
||||
* - 0 for a NULL value
|
||||
*/
|
||||
int getBytes() const noexcept
|
||||
{
|
||||
return sqlite3_column_bytes(*mStmtPtr, mIndex);
|
||||
}
|
||||
|
||||
|
||||
/// Alias returning the number of bytes used by the text (or blob) value of the column
|
||||
inline int size() const noexcept
|
||||
{
|
||||
return getBytes ();
|
||||
}
|
||||
|
||||
/// Inline cast operator to char
|
||||
inline operator char() const
|
||||
{
|
||||
return static_cast<char>(getInt());
|
||||
}
|
||||
/// Inline cast operator to unsigned char
|
||||
inline operator unsigned char() const
|
||||
{
|
||||
return static_cast<unsigned char>(getInt());
|
||||
}
|
||||
/// Inline cast operator to short
|
||||
inline operator short() const
|
||||
{
|
||||
return static_cast<short>(getInt());
|
||||
}
|
||||
/// Inline cast operator to unsigned short
|
||||
inline operator unsigned short() const
|
||||
{
|
||||
return static_cast<unsigned short>(getInt());
|
||||
}
|
||||
|
||||
/// Inline cast operator to int
|
||||
inline operator int() const
|
||||
{
|
||||
return getInt();
|
||||
}
|
||||
/// Inline cast operator to 32bits unsigned integer
|
||||
inline operator unsigned int() const
|
||||
{
|
||||
return getUInt();
|
||||
}
|
||||
#if (LONG_MAX == INT_MAX) // 4 bytes "long" type means the data model is ILP32 or LLP64 (Win64 Visual C++ and MinGW)
|
||||
/// Inline cast operator to 32bits long
|
||||
inline operator long() const
|
||||
{
|
||||
return getInt();
|
||||
}
|
||||
/// Inline cast operator to 32bits unsigned long
|
||||
inline operator unsigned long() const
|
||||
{
|
||||
return getUInt();
|
||||
}
|
||||
#else // 8 bytes "long" type means the data model is LP64 (Most Unix-like, Windows when using Cygwin; z/OS)
|
||||
/// Inline cast operator to 64bits long when the data model of the system is LP64 (Linux 64 bits...)
|
||||
inline operator long() const
|
||||
{
|
||||
return getInt64();
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Inline cast operator to 64bits integer
|
||||
inline operator long long() const
|
||||
{
|
||||
return getInt64();
|
||||
}
|
||||
/// Inline cast operator to double
|
||||
inline operator double() const
|
||||
{
|
||||
return getDouble();
|
||||
}
|
||||
/**
|
||||
* @brief Inline cast operator to char*
|
||||
*
|
||||
* @see getText
|
||||
*/
|
||||
inline operator const char*() const
|
||||
{
|
||||
return getText();
|
||||
}
|
||||
/**
|
||||
* @brief Inline cast operator to void*
|
||||
*
|
||||
* @see getBlob
|
||||
*/
|
||||
inline operator const void*() const
|
||||
{
|
||||
return getBlob();
|
||||
}
|
||||
|
||||
//#if !defined(_MSC_VER) || _MSC_VER >= 1900
|
||||
// // NOTE : the following is required by GCC and Clang to cast a Column result in a std::string
|
||||
// // (error: conversion from ‘SQLite::Column’ to non-scalar type ‘std::string {aka std::basic_string<char>}’)
|
||||
// // and also required for Microsoft Visual Studio 2015 and newer
|
||||
// // but is not working under Microsoft Visual Studio 2010, 2012 and 2013
|
||||
// // (error C2440: 'initializing' : cannot convert from 'SQLite::Column' to 'std::basic_string<_Elem,_Traits,_Ax>'
|
||||
// // [...] constructor overload resolution was ambiguous)
|
||||
// // WARNING: without it, trying to access a binary blob with implicit cast to string
|
||||
// // ends up converting it to a C-style char*, damaging the data by truncating it to the first null character!
|
||||
// // (see https://github.com/SRombauts/SQLiteCpp/issues/189 Visual Studio 2013: unit test "Column.basis" failing)
|
||||
// /**
|
||||
// * @brief Inline cast operator to std::string
|
||||
// *
|
||||
// * Handles BLOB or TEXT, which may contain null bytes within
|
||||
// *
|
||||
// * @see getString
|
||||
// */
|
||||
// inline operator std::string() const
|
||||
// {
|
||||
// return getString();
|
||||
// }
|
||||
//#endif
|
||||
|
||||
private:
|
||||
_StatementPtr mStmtPtr; ///< Shared Pointer to the prepared SQLite Statement Object
|
||||
int mIndex; ///< Index of the column in the row of result, starting at 0
|
||||
};
|
||||
|
||||
///**
|
||||
// * @brief Standard std::ostream text inserter
|
||||
// *
|
||||
// * Insert the text value of the Column object, using getText(), into the provided stream.
|
||||
// *
|
||||
// * @param[in] aStream Stream to use
|
||||
// * @param[in] aColumn Column object to insert into the provided stream
|
||||
// *
|
||||
// * @return Reference to the stream used
|
||||
// */
|
||||
//std::ostream& operator<<(std::ostream& aStream, const CSQLiteColumn& aColumn);
|
||||
|
||||
//#if __cplusplus >= 201402L || (defined(_MSC_VER) && _MSC_VER >= 1900)
|
||||
|
||||
//// Create an instance of T from the first N columns, see declaration in Statement.h for full details
|
||||
//template<typename T, int N>
|
||||
//T Statement::getColumns()
|
||||
//{
|
||||
// checkRow();
|
||||
// checkIndex(N - 1);
|
||||
// return getColumns<T>(std::make_integer_sequence<int, N>{});
|
||||
//}
|
||||
|
||||
//// Helper function called by getColums<typename T, int N>
|
||||
//template<typename T, const int... Is>
|
||||
//T Statement::getColumns(const std::integer_sequence<int, Is...>)
|
||||
//{
|
||||
// return T{Column(mStmtPtr, Is)...};
|
||||
//}
|
||||
|
||||
//#endif
|
||||
Reference in New Issue
Block a user