SQLQueryHolder Class Reference

#include <QueryHolder.h>

Public Member Functions
	SQLQueryHolder ()
virtual	~SQLQueryHolder ()
bool	SetQuery (size_t index, const char *sql)
template<typename Format , typename... Args>
bool	SetPQuery (size_t index, Format &&sql, Args &&...args)
bool	SetPreparedQuery (size_t index, PreparedStatement *stmt)
void	SetSize (size_t size)
QueryResult	GetResult (size_t index)
PreparedQueryResult	GetPreparedResult (size_t index)
void	SetResult (size_t index, ResultSet *result)
void	SetPreparedResult (size_t index, PreparedResultSet *result)

Private Types
typedef std::pair < SQLElementData, SQLResultSetUnion >	SQLResultPair

Private Attributes
std::vector< SQLResultPair >	m_queries

Friends
class	SQLQueryHolderTask

Member Typedef Documentation

typedef std::pair<SQLElementData, SQLResultSetUnion> SQLQueryHolder::SQLResultPair

private

Constructor & Destructor Documentation

SQLQueryHolder::SQLQueryHolder ( )

inline

{ }

SQLQueryHolder::~SQLQueryHolder ( )

virtual

if the result was never used, free the resources results used already (getresult called) are expected to be deleted

{
 for (size_t i = 0; i < m_queries.size(); i++)
 {
 if (SQLElementData* data = &m_queries[i].first)
 {
 switch (data->type)
 {
 case SQL_ELEMENT_RAW:
 free((void*)(const_cast<char*>(data->element.query)));
 break;
 case SQL_ELEMENT_PREPARED:
 delete data->element.stmt;
 break;
 }
 }
 }
}

Member Function Documentation

PreparedQueryResult SQLQueryHolder::GetPreparedResult

(

size_t

index

)

{
 // Don't call to this function if the index is of a prepared statement
 if (index < m_queries.size())
 {
 PreparedResultSet* result = m_queries[index].second.presult;
 if (!result || !result->GetRowCount())
 return PreparedQueryResult(NULL);

 return PreparedQueryResult(result);
 }
 else
 return PreparedQueryResult(NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

QueryResult SQLQueryHolder::GetResult

(

size_t

index

)

{
 // Don't call to this function if the index is of an ad-hoc statement
 if (index < m_queries.size())
 {
 ResultSet* result = m_queries[index].second.qresult;
 if (!result || !result->GetRowCount() || !result->NextRow())
 return QueryResult(NULL);

 return QueryResult(result);
 }
 else
 return QueryResult(NULL);
}

Here is the call graph for this function:

template<typename Format , typename... Args>

bool SQLQueryHolder::SetPQuery ( size_t  index, Format &&  sql, Args &&...  args  )

inline

 {
 return SetQuery(index, Trinity::StringFormat(std::forward<Format>(sql), std::forward<Args>(args)...).c_str());
 }

Here is the call graph for this function:

bool SQLQueryHolder::SetPreparedQuery	(	size_t	index,
		PreparedStatement *	stmt
	)

not executed yet, just stored (it's not called a holder for nothing)

{
 if (m_queries.size() <= index)
 {
 TC_LOG_ERROR("sql.sql", "Query index (%u) out of range (size: %u) for prepared statement", uint32(index), (uint32)m_queries.size());
 return false;
 }

 SQLElementData element;
 element.type = SQL_ELEMENT_PREPARED;
 element.element.stmt = stmt;

 SQLResultSetUnion result;
 result.presult = NULL;

 m_queries[index] = SQLResultPair(element, result);
 return true;
}

Here is the caller graph for this function:

void SQLQueryHolder::SetPreparedResult	(	size_t	index,
		PreparedResultSet *	result
	)

store the result in the holder

{
 if (result && !result->GetRowCount())
 {
 delete result;
 result = NULL;
 }

 if (index < m_queries.size())
 m_queries[index].second.presult = result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool SQLQueryHolder::SetQuery	(	size_t	index,
		const char *	sql
	)

not executed yet, just stored (it's not called a holder for nothing)

{
 if (m_queries.size() <= index)
 {
 TC_LOG_ERROR("sql.sql", "Query index (%u) out of range (size: %u) for query: %s", uint32(index), (uint32)m_queries.size(), sql);
 return false;
 }

 SQLElementData element;
 element.type = SQL_ELEMENT_RAW;
 element.element.query = strdup(sql);

 SQLResultSetUnion result;
 result.qresult = NULL;

 m_queries[index] = SQLResultPair(element, result);
 return true;
}

void SQLQueryHolder::SetResult	(	size_t	index,
		ResultSet *	result
	)

store the result in the holder

{
 if (result && !result->GetRowCount())
 {
 delete result;
 result = NULL;
 }

 if (index < m_queries.size())
 m_queries[index].second.qresult = result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SQLQueryHolder::SetSize

(

size_t

size

)

to optimize push_back, reserve the number of queries about to be executed

{
 m_queries.resize(size);
}

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class SQLQueryHolderTask

friend

Member Data Documentation

std::vector<SQLResultPair> SQLQueryHolder::m_queries

private

---

The documentation for this class was generated from the following files:

• src/server/database/Database/QueryHolder.h
• src/server/database/Database/QueryHolder.cpp