int FileToString( const char* filename, std::string& out_contents )
{
FILE *fp;
fp = fopen(filename,"r");
if (!fp)
{
printf("Unable to open file '%s' for read into string (%s, %d)\n",filename, __FILE__, __LINE__);
return 1;
}
const size_t capacity_increment = 512;
try
{
out_contents.clear();
out_contents.reserve(capacity_increment);
for (int this_char = fgetc(fp); this_char != EOF; this_char = fgetc(fp))
{
//embiggenate the buffer, if needed
if(out_contents.capacity() == out_contents.size())
{
out_contents.reserve(out_contents.capacity() + capacity_increment);
}
out_contents.push_back(static_cast<char>(this_char));
}
}
catch (const std::exception& e)
{
printf("caught exception '%s' while reading file '%s' into string (%s, %d)\n",e.what(), filename, __FILE__, __LINE__);
return 1;
}
return 0;
}
void load_file(std::string& s, std::istream& is)
{
s.erase();
if(is.bad()) return;
s.reserve(static_cast<std::string::size_type>(is.rdbuf()->in_avail()));
char c;
while(is.get(c))
{
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c);
}
}
void Dow::Handle::GetClassName (std::string & name) const
{
// Revisit: there is better API RealGetWindowClass, but it is supported
// only in Win98, NT 4.0 with SP3 and Win2000
unsigned lenAvailable = 128;
unsigned lenWritten = 0;
do
{
name.reserve (lenAvailable); // could reserve more
lenWritten = ::GetClassName (H (), writable_string (name), name.capacity ());
lenAvailable = 2 * name.capacity ();
} while (lenWritten + 1 == name.capacity ());
}
void load_file1(std::string& s, std::istream& is)
{
s.erase(); //删除字符串
//bad() 如果出现错误则返回true
if(is.bad()) return;
s.reserve(is.rdbuf()->in_avail()); //reserve 预留空间
char c;
while(is.get(c))
{ //capacity 在不重新分配内存的情况下，字符串可能的大小 size 得到字符串的大小
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c); //append 追加字符
}
}
// original source:
// https://github.com/facebook/folly/blob/master/folly/String.cpp
//
void vStringFormat(std::string& output, const char* format, va_list args)
{
va_list tmpargs;
va_copy(tmpargs,args);
int characters_used = vsnprintf(nullptr, 0, format, tmpargs);
va_end(tmpargs);
if (characters_used < 0) {
// Looks like we have an invalid format string.
// error out.
std::string errorMessage("Invalid format string; snprintf returned negative with format string: ");
errorMessage.append(format);
throw std::runtime_error(errorMessage);
}
else if ((unsigned int)characters_used > output.capacity()) {
output.resize(characters_used+1);
va_copy(tmpargs,args);
characters_used = vsnprintf(&output[0], output.capacity(), format, tmpargs);
va_end(tmpargs);
if (characters_used < 0) {
// We shouldn't have a format error by this point, but I can't imagine what error we
// could have by this point. Still, error out and report it.
std::string errorMessage("Invalid format string or unknown vsnprintf error; vsnprintf returned negative with format string: ");
errorMessage.append(format);
throw std::runtime_error(errorMessage);
}
}
else {
output.resize(characters_used + 1);
va_copy(tmpargs,args);
characters_used = vsnprintf(&output[0], output.capacity(), format, tmpargs);
va_end(tmpargs);
if (characters_used < 0) {
// We shouldn't have a format error by this point, but I can't imagine what error we
// could have by this point. still error out and report it.
std::string errorMessage("Invalid format string or unknown vsnprintf error; vsnprintf returned negative with format string: ");
errorMessage.append(format);
throw std::runtime_error(errorMessage);
}
}
}
std::string escape(const std::string str, bool intag = true)
{
std::string ret = str;
ret.reserve(str.capacity() * 2);
for (const char c : str) {
if (c == '<') {
ret += "<";
}
else if (c == '>') {
ret += ">";
}
else if (c == '&') {
ret += "&";
}
else if (intag) {
if (c == '\'') {
ret += "&abuff;";
}
else if (c == '\"') {
ret += """;
}
else {
ret += c;
}
}
else {
ret += c;
}
}
return ret;
}
std::string EscapeForHTML(const std::string& str)
{
typedef std::map<char, std::string> EscapeMap;
static const EscapeMap kHtmlEscapeMap {
{ '<', "<" },
{ '>', ">" },
{ '&', "&" },
{ '"', """ },
{ '\'', "'" },
};
std::string strResult;
strResult.reserve(str.capacity());
for (auto v : str)
{
auto i = kHtmlEscapeMap.find(v);
if (i == kHtmlEscapeMap.end())
{
strResult.push_back(v);
continue;
}
strResult.append(i->second);
}
return strResult;
}
void encoder::encode(std::string& s) {
s.resize(std::max(s.capacity(), size_t(1))); // Use full capacity, ensure not empty
size_t size = s.size();
if (!encode(&s[0], size)) {
s.resize(size);
encode(&s[0], size);
}
}
void load_file(std::string& s, std::istream& is)
{
s.erase();
//
// attempt to grow string buffer to match file size,
// this doesn't always work...
s.reserve(is.rdbuf()->in_avail());
char c;
while(is.get(c))
{
// use logarithmic growth stategy, in case
// in_avail (above) returned zero:
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c);
}
}
void write(std::string& s, const char* from, const char* to) {
assert(from <= to);
const size_t addCount = to - from;
if ( s.capacity() <= s.size() + addCount )
{
s.reserve( 2 * s.size() + addCount );
}
s.append(from, to);
}
void TCPSocket::Getline(std::string& buffer, bool stripCRLF)
{
buffer.clear();
buffer.reserve(defaultBufferSize);
char ch;
do
{
ch = GetcharBuffered();
if (!stripCRLF || (ch != '\r' && ch != '\n'))
{
buffer += ch;
if (buffer.length() == buffer.capacity())
buffer.reserve((buffer.capacity() / defaultBufferSize) + 1);
}
}
while (ch != '\n');
}
static std::string ConvertToLower(std::string const& inString)
{
std::string outString;
outString.reserve(inString.capacity());
for (uint32_t i=0; i<inString.length(); i++) {
outString+=tolower(inString[i]);
}
return outString;
}
void func (std::string a, std::wstring b)
{
printf ("%s\n", a.c_str());
printf ("%d\n", a.size());
printf ("%d\n", a.capacity());
wprintf (L"%s\n", b.c_str());
printf ("%d\n", b.size());
printf ("%d\n", b.capacity());
};
bool ShowAndGetNewPassword(
std::string& strNewPassword,
unsigned int autoCloseMs)
{
strNewPassword.resize(1024);
unsigned int size = (unsigned int)strNewPassword.capacity();
bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetNewPassword(strNewPassword[0], size, autoCloseMs);
strNewPassword.resize(size);
strNewPassword.shrink_to_fit();
return ret;
}
uint32_t
MemoryConsumption::getStringMemoryUsage(const std::string& s, uint32_t& uniqueCount) {
++_totalStringCount;
const char* internalString = s.c_str();
if (_seenStrings->find(internalString) != _seenStrings->end()) {
return 0;
}
++uniqueCount;
_seenStrings->insert(internalString);
return s.capacity();
}
bool ShowAndGetInput(
std::string& strText,
bool allowEmptyResult,
unsigned int autoCloseMs)
{
strText.resize(1024);
unsigned int size = (unsigned int)strText.capacity();
bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetInput(strText[0], size, allowEmptyResult, autoCloseMs);
strText.resize(size);
strText.shrink_to_fit();
return ret;
}
bool ShowAndGetFilter(
std::string& strText,
bool searching,
unsigned int autoCloseMs)
{
strText.resize(1024);
unsigned int size = (unsigned int)strText.capacity();
bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetFilter(strText[0], size, searching, autoCloseMs);
strText.resize(size);
strText.shrink_to_fit();
return ret;
}
/**
* Like calling s.resize(n), but when growing the string does not
* initialize new elements. It is undefined behavior to read from
* any element added to the string by this method unless it has been
* written to by an operation that follows this call.
*
* IMPORTANT: Read the warning at the top of this header file.
*/
inline void resizeWithoutInitialization(std::string& s, std::size_t n) {
if (n <= s.size()) {
s.resize(n);
} else {
// careful not to call reserve unless necessary, as it causes
// shrink_to_fit on many platforms
if (n > s.capacity()) {
s.reserve(n);
}
detail::unsafeStringSetLargerSize(s, n);
}
}
bool ShowAndVerifyNewPassword(
std::string& strNewPassword,
const std::string& strHeading,
bool allowEmptyResult,
unsigned int autoCloseMs)
{
strNewPassword.resize(1024);
unsigned int size = (unsigned int)strNewPassword.capacity();
bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetNewPasswordWithHead(strNewPassword[0], size, strHeading.c_str(), allowEmptyResult, autoCloseMs);
strNewPassword.resize(size);
strNewPassword.shrink_to_fit();
return ret;
}
int ShowAndVerifyPassword(
std::string& strPassword,
const std::string& strHeading,
int iRetries,
unsigned int autoCloseMs)
{
strPassword.resize(1024);
unsigned int size = (unsigned int)strPassword.capacity();
int ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndVerifyPassword(strPassword[0], size, strHeading.c_str(), iRetries, autoCloseMs);
strPassword.resize(size);
strPassword.shrink_to_fit();
return ret;
}
bool to_string(std::string& s, int val)
{
s.resize(s.capacity());
while (true)
{
size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size() + 1, "%d", val));
if (n2 <= s.size())
{
s.resize(n2);
break;
}
s.resize(n2);
}
return true;
}
static void extract(const jsonpack::value &v, char* json_ptr, std::string &value)
{
position p = v._pos;
if(p._type != JTK_NULL)
{
// pritty but slow and dangerous
// value.resize(p._count);
// memcpy( const_cast<char*>(value.data()), json_ptr+ p._pos, p._count); // FIX undefined behavior
// unsigned i = 0;
// value.erase(std::remove_if(value.begin(), value.end(),
// [&i, value](char c)->bool
// {
// bool esc = ( c == '\\' && (i < value.length()-1 ) && (sizeof(char) == 1 || unsigned(value[i+1]) < 256) && util::escaped[(unsigned char)value[i+1]] );
// i++;
// return esc;
// }),
// value.end() );
//hard coded but fast and safe
if (value.capacity() < p._count + 1)
value.reserve(p._count + 1);
char* val_ptr = json_ptr + p._pos;
for(char* i = val_ptr ; i != val_ptr + p._count ; ++i)
{
if( *i == '\\' )
{
++i;
if( (i != val_ptr + p._count) && ( sizeof(char) == 1 || unsigned(*i) < 256) && util::escaped[(unsigned char)*i] )
value.push_back(*i);
}
else
value.push_back(*i);
}
}
}
bool ImGui::InputTextM(const char* label, std::string& text)
{
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32) || (CC_TARGET_PLATFORM == CC_PLATFORM_MAC) || (CC_TARGET_PLATFORM == CC_PLATFORM_LINUX)
bool ret = InputTextEx(label, &text[0], text.capacity(), ImVec2(0, 0), 0, 0, nullptr);
return ret;
#else
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiContext& g = *GImGui;
const ImGuiIO& io = g.IO;
const ImGuiStyle& style = g.Style;
//============================================
const ImGuiID id = window->GetID(label);
const ImVec2 label_size = CalcTextSize(label, NULL, true);
ImVec2 size = CalcItemSize(ImVec2(0, 0), CalcItemWidth(), label_size.y + style.FramePadding.y*2.0f);
const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + size);
const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? (style.ItemInnerSpacing.x + label_size.x) : 0.0f, 0.0f));
//============================================
ItemSize(total_bb, style.FramePadding.y);
if (!ItemAdd(total_bb, &id))
return false;
const bool hovered = IsHovered(frame_bb, id);
if (hovered)
{
SetHoveredID(id);
g.MouseCursor = ImGuiMouseCursor_TextInput;
}
ImGuiTextEditState& edit_state = g.InputTextState;
const bool user_clicked = hovered && io.MouseClicked[0];
if (user_clicked)
{
if (g.ActiveId != id)
{
edit_state.CursorAnimReset();
}
SetActiveID(id, window);
FocusWindow(window);
}
else if (io.MouseClicked[0])
{
// Release focus when we click outside
if (g.ActiveId == id)
SetActiveID(0, NULL);
}
if (g.ActiveId == id)
{
//window->DrawList->AddRectFilled(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_TextSelectedBg), style.FrameRounding);
RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_TextSelectedBg), true, style.FrameRounding);
ImRect frame_select(frame_bb);
frame_select.Reduce(ImVec2(2, 2));
RenderFrame(frame_select.Min, frame_select.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
}else
{
RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
}
//============================================
int w = snprintf(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), "%s", text.c_str());
int tempSize = IM_ARRAYSIZE(g.TempBuffer);
g.TempBuffer[tempSize - 1] = 0;
const char* text_end = g.TempBuffer + ((w == -1) ? tempSize : w);
// Render Text
const ImVec4 clip_rect(frame_bb.Min.x, frame_bb.Min.y, frame_bb.Min.x + size.x, frame_bb.Min.y + size.y); // Not using frame_bb.Max because we have adjusted size
ImVec2 render_pos = frame_bb.Min + style.FramePadding;
window->DrawList->AddText(g.Font, g.FontSize, render_pos, GetColorU32(ImGuiCol_Text), g.TempBuffer, text_end, 0.0f, &clip_rect);
if (label_size.x > 0)
RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
return user_clicked;
#endif
}
void insert_objects(MYSQL* conn, const char* table_name, time_t epoch, uint index, std::vector<Libpair>& lddA,
std::string& syshost, Table& rmapT)
{
//************************************************************
// build SELECT obj_id INTO xalt_object stmt
//************************************************************
const char* stmt_sql_s = "SELECT obj_id FROM xalt_object WHERE hash_id=? AND object_path=? AND syshost=? limit 1";
MYSQL_STMT *stmt_s = mysql_stmt_init(conn);
if (!stmt_s)
{
print_stmt_error(stmt_s, "mysql_stmt_init(), out of memmory",__FILE__,__LINE__);
exit(1);
}
if (mysql_stmt_prepare(stmt_s, stmt_sql_s, strlen(stmt_sql_s)))
{
print_stmt_error(stmt_s, "Could not prepare stmt_s for select obj_id",__FILE__,__LINE__);
exit(1);
}
MYSQL_BIND param_s[3], result_s[1];
memset((void *) param_s, 0, sizeof(param_s));
memset((void *) result_s, 0, sizeof(result_s));
const int hash_id_sz = 41;
char hash_id[hash_id_sz];
const int objSz = 2048;
char object_path[objSz];
// STRING PARAM_S[0] hash_id;
std::string::size_type len_hash_id = 0; // set length later in loop.
param_s[0].buffer_type = MYSQL_TYPE_STRING;
param_s[0].buffer = (void *) &hash_id[0];
param_s[0].buffer_length = hash_id_sz;
param_s[0].length = &len_hash_id;
// STRING PARAM_S[1] object_path
std::string::size_type len_object_path = 0; // set length later in loop.
param_s[1].buffer_type = MYSQL_TYPE_STRING;
param_s[1].buffer = (void *) &object_path[0];
param_s[1].buffer_length = objSz;
param_s[1].length = &len_object_path;
// STRING PARAM_S[2] syshost
std::string::size_type len_syshost = syshost.size();
param_s[2].buffer_type = MYSQL_TYPE_STRING;
param_s[2].buffer = (void *) syshost.c_str();
param_s[2].buffer_length = syshost.capacity();
param_s[2].length = &len_syshost;
if (mysql_stmt_bind_param(stmt_s, param_s))
{
print_stmt_error(stmt_s, "Could not bind paramaters for selecting obj_id(1)",__FILE__,__LINE__);
exit(1);
}
// UNSIGNED INT RESULT_S obj_id;
uint obj_id;
result_s[0].buffer_type = MYSQL_TYPE_LONG;
result_s[0].buffer = (void *) &obj_id;
result_s[0].is_unsigned = 1;
result_s[0].length = 0;
if (mysql_stmt_bind_result(stmt_s, result_s))
{
print_stmt_error(stmt_s, "Could not bind paramaters for selecting obj_id(2)",__FILE__,__LINE__);
exit(1);
}
//************************************************************
// build INSERT into xalt_object stmt
//************************************************************
const char* stmt_sql_i = "INSERT INTO xalt_object VALUES (NULL,?,?,?,?,?,?)";
MYSQL_STMT *stmt_i = mysql_stmt_init(conn);
if (!stmt_i)
{
print_stmt_error(stmt_i, "mysql_stmt_init(), out of memmory(2)",__FILE__,__LINE__);
exit(1);
}
if (mysql_stmt_prepare(stmt_i, stmt_sql_i, strlen(stmt_sql_i)))
{
print_stmt_error(stmt_i, "Could not prepare stmt_i for insert into xalt_object",__FILE__,__LINE__);
exit(1);
}
MYSQL_BIND param_i[6];
memset((void *) param_i, 0, sizeof(param_i));
// STRING PARAM_I[0] object_path
param_i[0].buffer_type = MYSQL_TYPE_STRING;
param_i[0].buffer = (void *) &object_path[0];
param_i[0].buffer_length = objSz;
param_i[0].length = &len_object_path;
// STRING PARAM_I[1] syshost
param_i[1].buffer_type = MYSQL_TYPE_STRING;
param_i[1].buffer = (void *) syshost.c_str();
param_i[1].buffer_length = syshost.capacity();
param_i[1].length = &len_syshost;
// STRING PARAM_I[2] hash_id
param_i[2].buffer_type = MYSQL_TYPE_STRING;
param_i[2].buffer = (void *) &hash_id[0];
param_i[2].buffer_length = hash_id_sz;
param_i[2].length = &len_hash_id;
// STRING PARAM_I[3] module_name
const int module_name_sz = 64;
char module_name[module_name_sz];
std::string::size_type len_module_name = 0; // set length in loop
my_bool module_name_null_flag;
param_i[3].buffer_type = MYSQL_TYPE_STRING;
param_i[3].buffer = (void *) &module_name[0];
param_i[3].buffer_length = module_name_sz;
param_i[3].is_null = &module_name_null_flag;
param_i[3].length = &len_module_name;
// TIMESTAMP PARAM_I[4] timestamp
MYSQL_TIME my_datetime;
time_t clock;
(void ) time(&clock);
struct tm* curr_time = localtime(&clock);
my_datetime.year = curr_time->tm_year + 1900;
my_datetime.month = curr_time->tm_mon + 1;
my_datetime.day = curr_time->tm_mday;
my_datetime.hour = curr_time->tm_hour;
my_datetime.minute = curr_time->tm_min;
my_datetime.second = curr_time->tm_sec;
my_datetime.second_part = 0;
param_i[4].buffer_type = MYSQL_TYPE_DATETIME;
param_i[4].buffer = &my_datetime;
// STRING PARAM_I[5] lib_type
const int lib_type_sz = 3;
char lib_type[lib_type_sz];
std::string::size_type len_lib_type = 0; // set length in loop.
param_i[5].buffer_type = MYSQL_TYPE_STRING;
param_i[5].buffer = (void *) &lib_type[0];
param_i[5].buffer_length = lib_type_sz;
param_i[5].length = &len_lib_type;
if (mysql_stmt_bind_param(stmt_i, param_i))
{
print_stmt_error(stmt_i, "Could not bind paramaters for inserting into xalt_object",__FILE__,__LINE__);
exit(1);
}
//************************************************************
// "INSERT into <TABLE_NAME> VALUES (NULL, ?, ?, ?)"
//************************************************************
std::string s2("INSERT INTO ");
s2.append(table_name);
s2.append(" VALUES (NULL,?,?,?)");
const char* stmt_sql_ii = s2.c_str();
MYSQL_STMT *stmt_ii = mysql_stmt_init(conn);
if (!stmt_ii)
{
print_stmt_error(stmt_ii, "mysql_stmt_init(), out of memmory(3)",__FILE__,__LINE__);
exit(1);
}
if (mysql_stmt_prepare(stmt_ii, stmt_sql_ii, strlen(stmt_sql_ii)))
{
print_stmt_error(stmt_ii, "Could not prepare stmt_ii for insert into <table_name>",__FILE__,__LINE__);
exit(1);
}
MYSQL_BIND param_ii[3];
memset((void *) param_ii, 0, sizeof(param_ii));
// UINT PARAM_II[0] obj_id
param_ii[0].buffer_type = MYSQL_TYPE_LONG;
param_ii[0].buffer = (void *) &obj_id;
param_ii[0].buffer_length = 0;
param_ii[0].is_unsigned = 1;
// UINT PARAM_II[1] index
param_ii[1].buffer_type = MYSQL_TYPE_LONG;
param_ii[1].buffer = (void *) &index;
param_ii[1].buffer_length = 0;
param_ii[1].is_unsigned = 1;
// DATE PARAM_II[2] date
MYSQL_TIME my_date;
curr_time = localtime(&epoch);
my_date.year = curr_time->tm_year + 1900;
my_date.month = curr_time->tm_mon + 1;
my_date.day = curr_time->tm_mday;
my_date.hour = 0;
my_date.minute = 0;
my_date.second = 0;
my_date.second_part = 0;
param_ii[2].buffer_type = MYSQL_TYPE_DATE;
param_ii[2].buffer = &my_date;
if (mysql_stmt_bind_param(stmt_ii, param_ii))
{
print_stmt_error(stmt_ii, "Could not bind paramaters for inserting into xalt_object",__FILE__,__LINE__);
exit(1);
}
for ( auto const & it : lddA)
{
len_object_path = it.lib.size();
strcpy(object_path, it.lib.c_str());
len_hash_id = it.sha1.size();
strcpy(hash_id, it.sha1.c_str());
// "SELECT obj_id ..."
if (mysql_stmt_execute(stmt_s))
{
print_stmt_error(stmt_s, "Could not execute stmt for selecting obj_id",__FILE__,__LINE__);
exit(1);
}
if (mysql_stmt_store_result(stmt_s))
{
print_stmt_error(stmt_s, "Could not mysql_stmt_store_result() selecting obj_id",__FILE__,__LINE__);
exit(1);
}
// mysql_stmt_fetch(stmt_s) will return 0 if successful. That means it found obj_id
if (mysql_stmt_fetch(stmt_s) != 0)
{
// If here then the object is NOT in the db so store it and compute obj_id
if (path2module(object_path, rmapT, module_name, module_name_sz))
{
module_name_null_flag = 0;
len_module_name = strlen(module_name);
}
else
{
module_name_null_flag = 1;
len_module_name = 0;
}
object_type(object_path, &lib_type[0]);
len_lib_type = strlen(lib_type);
// "INSERT INTO xalt_object ..."
if (mysql_stmt_execute(stmt_i))
{
print_stmt_error(stmt_i, "Could not execute stmt for inserting into xalt_object",__FILE__,__LINE__);
exit(1);
}
obj_id = (uint) mysql_stmt_insert_id(stmt_i);
}
// "INSERT INTO <table_name>"
if (mysql_stmt_execute(stmt_ii))
{
print_stmt_error(stmt_ii, "Could not execute stmt for inserting into <table_name>",__FILE__,__LINE__);
exit(1);
}
}
mysql_stmt_free_result(stmt_s);
if (mysql_stmt_close(stmt_s))
{
print_stmt_error(stmt_s, "Could not close stmt for selecting obj_id",__FILE__,__LINE__);
exit(1);
}
if (mysql_stmt_close(stmt_i))
{
print_stmt_error(stmt_i, "Could not close stmt for inserting into xalt_object",__FILE__,__LINE__);
exit(1);
}
if (mysql_stmt_close(stmt_ii))
{
print_stmt_error(stmt_ii, "Could not close stmt for inserting into <table_name>",__FILE__,__LINE__);
exit(1);
}
}
bool SQL_RAW::callProtocol(std::string input_str, std::string &result, const bool async_method, const unsigned int unique_id)
{
try
{
#ifdef DEBUG_TESTING
extension_ptr->console->info("extDB2: SQL_RAW: Trace: Input: {0}", input_str);
#endif
#ifdef DEBUG_LOGGING
extension_ptr->logger->info("extDB2: SQL_RAW: Trace: Input: {0}", input_str);
#endif
Poco::Data::Session session = extension_ptr->getDBSession_mutexlock(*database_ptr);
Poco::Data::RecordSet rs(session, input_str);
result = "[1,[";
std::string temp_str;
temp_str.reserve(result.capacity());
std::size_t cols = rs.columnCount();
if (cols >= 1)
{
result += "[";
bool more = rs.moveFirst();
while (more)
{
for (std::size_t col = 0; col < cols; ++col)
{
if (rs[col].isEmpty())
{
temp_str.clear();
}
else
{
temp_str = rs[col].convert<std::string>();
}
auto datatype = rs.columnType(col);
if ((datatype == Poco::Data::MetaColumn::FDT_DATE) || (datatype == Poco::Data::MetaColumn::FDT_TIME) || (datatype == Poco::Data::MetaColumn::FDT_TIMESTAMP))
{
if (temp_str.empty())
{
result += "\"\"";
}
else
{
boost::erase_all(temp_str, "\"");
result += "\"" + temp_str + "\"";
}
}
else if ((stringDataTypeCheck) && (rs.columnType(col) == Poco::Data::MetaColumn::FDT_STRING))
{
if (temp_str.empty())
{
result += ("\"\"");
}
else
{
boost::erase_all(temp_str, "\"");
result += "\"" + temp_str + "\"";
}
}
else
{
if (temp_str.empty())
{
result += "\"\"";
}
else
{
result += temp_str;
}
}
if (col < (cols - 1))
{
result += ",";
}
}
more = rs.moveNext();
if (more)
{
result += "],[";
}
}
result += "]";
}
result += "]]";
#ifdef DEBUG_TESTING
extension_ptr->console->info("extDB2: SQL_RAW: Trace: Result: {0}", result);
#endif
#ifdef DEBUG_LOGGING
extension_ptr->logger->info("extDB2: SQL_RAW: Trace: Result: {0}", result);
#endif
}
catch (Poco::InvalidAccessException& e)
{
#ifdef DEBUG_TESTING
extension_ptr->console->error("extDB2: SQL_RAW: Error InvalidAccessException: {0}", e.displayText());
extension_ptr->console->error("extDB2: SQL_RAW: Error InvalidAccessException: SQL: {0}", input_str);
#endif
extension_ptr->logger->error("extDB2: SQL_RAW: Error InvalidAccessException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error InvalidAccessException: SQL: {0}", input_str);
result = "[0,\"Error DBLocked Exception\"]";
}
catch (Poco::Data::NotConnectedException& e)
{
#ifdef DEBUG_TESTING
extension_ptr->console->error("extDB2: SQL_RAW: Error NotConnectedException: {0}", e.displayText());
extension_ptr->console->error("extDB2: SQL_RAW: Error NotConnectedException: SQL: {0}", input_str);
#endif
extension_ptr->logger->error("extDB2: SQL_RAW: Error NotConnectedException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error NotConnectedException: SQL: {0}", input_str);
result = "[0,\"Error DBLocked Exception\"]";
}
catch (Poco::NotImplementedException& e)
{
#ifdef DEBUG_TESTING
extension_ptr->console->error("extDB2: SQL_RAW: Error NotImplementedException: {0}", e.displayText());
extension_ptr->console->error("extDB2: SQL_RAW: Error NotImplementedException: SQL: {0}", input_str);
#endif
extension_ptr->logger->error("extDB2: SQL_RAW: Error NotImplementedException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error NotImplementedException: SQL: {0}", input_str);
result = "[0,\"Error DBLocked Exception\"]";
}
catch (Poco::Data::SQLite::DBLockedException& e)
{
#ifdef DEBUG_TESTING
extension_ptr->console->error("extDB2: SQL_RAW: Error DBLockedException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error DBLockedException: SQL: {0}", input_str);
#endif
extension_ptr->logger->error("extDB2: SQL_RAW: Error DBLockedException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error DBLockedException: SQL: {0}", input_str);
result = "[0,\"Error DBLocked Exception\"]";
}
catch (Poco::Data::MySQL::ConnectionException& e)
{
#ifdef DEBUG_TESTING
extension_ptr->console->error("extDB2: SQL_RAW: Error ConnectionException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error ConnectionException: SQL: {0}", input_str);
#endif
extension_ptr->logger->error("extDB2: SQL_RAW: Error ConnectionException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error ConnectionException: SQL: {0}", input_str);
result = "[0,\"Error Connection Exception\"]";
}
catch(Poco::Data::MySQL::StatementException& e)
{
#ifdef DEBUG_TESTING
extension_ptr->console->error("extDB2: SQL_RAW: Error StatementException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error StatementException: SQL: {0}", input_str);
#endif
extension_ptr->logger->error("extDB2: SQL_RAW: Error StatementException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error StatementException: SQL: {0}", input_str);
result = "[0,\"Error Statement Exception\"]";
}
catch (Poco::Data::ConnectionFailedException& e)
{
#ifdef DEBUG_TESTING
extension_ptr->console->error("extDB2: SQL_RAW: Error ConnectionFailedException: {0}", e.displayText());
extension_ptr->console->error("extDB2: SQL_RAW: Error ConnectionFailedException: SQL {0}", input_str);
#endif
extension_ptr->logger->error("extDB2: SQL_RAW: Error ConnectionFailedException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error ConnectionFailedException: SQL {0}", input_str);
result = "[0,\"Error ConnectionFailedException\"]";
}
catch (Poco::Data::DataException& e)
{
#ifdef DEBUG_TESTING
extension_ptr->console->error("extDB2: SQL_RAW: Error DataException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error DataException: SQL: {0}", input_str);
#endif
extension_ptr->logger->error("extDB2: SQL_RAW: Error DataException: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error DataException: SQL: {0}", input_str);
result = "[0,\"Error Data Exception\"]";
}
catch (Poco::Exception& e)
{
#ifdef DEBUG_TESTING
extension_ptr->console->error("extDB2: SQL_RAW: Error Exception: {0}", e.displayText());
extension_ptr->console->error("extDB2: SQL_RAW: Error Exception: SQL: {0}", input_str);
#endif
extension_ptr->logger->error("extDB2: SQL_RAW: Error Exception: {0}", e.displayText());
extension_ptr->logger->error("extDB2: SQL_RAW: Error Exception: SQL: {0}", input_str);
result = "[0,\"Error Exception\"]";
}
return true;
}
size_t GetCapacity() { return m_Data->capacity(); }
void quasardb_facade::blob_get_noalloc(const std::string & alias, std::string & content)
{
std::size_t result_size = content.capacity();
INVOKE(qdb_blob_get_noalloc, _handle, alias.c_str(), const_cast<char *>(content.data()), &result_size);
content.resize(result_size);
}