query_string_builder.h

/*
 * Copyright (c) 2015, 2025, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0,
 * as published by the Free Software Foundation.
 *
 * This program is designed to work with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms,
 * as designated in a particular file or component or in included license
 * documentation. The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have either included with
 * the program or referenced in the documentation.
 *
 * This program 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 General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/

#ifndef PLUGIN_X_SRC_QUERY_STRING_BUILDER_H_
#definePLUGIN_X_SRC_QUERY_STRING_BUILDER_H_

#include<stdint.h>
#include<string.h>
#include<mutex>// NOLINT(build/c++11)
#include<string>

#include"plugin/x/src/ngs/memory.h"
#include"plugin/x/src/ngs/thread.h"
#include"plugin/x/src/query_formatter.h"

structCHARSET_INFO;

namespacexpl {

classQuery_string_builder {
public:
explicitQuery_string_builder(size_t reserve = 256);

 Query_string_builder &bquote() {
 m_str.push_back('\'');
 m_in_quoted = true;
return *this;
 }

 Query_string_builder &equote() {
 m_str.push_back('\'');
 m_in_quoted = false;
return *this;
 }

 Query_string_builder &bident() {
 m_str.push_back('`');
 m_in_identifier = true;
return *this;
 }

 Query_string_builder &eident() {
 m_str.push_back('`');
 m_in_identifier = false;
return *this;
 }

 Query_string_builder &quote_identifier_if_needed(constchar *s,
size_t length);
 Query_string_builder &quote_identifier(constchar *s, size_t length);
 Query_string_builder &quote_string(constchar *s, size_t length);
 Query_string_builder &quote_json_string(constchar *s, size_t length);

 Query_string_builder &quote_identifier_if_needed(const std::string &s) {
returnquote_identifier_if_needed(s.data(), s.length());
 }

 Query_string_builder &quote_identifier(const std::string &s) {
returnquote_identifier(s.data(), s.length());
 }

 Query_string_builder &quote_string(const std::string &s) {
returnquote_string(s.data(), s.length());
 }

 Query_string_builder &quote_json_string(const std::string &s) {
returnquote_json_string(s.data(), s.length());
 }

 Query_string_builder &escape_identifier(constchar *s, size_t length);
 Query_string_builder &escape_string(constchar *s, size_t length);
 Query_string_builder &escape_json_string(constchar *s, size_t length);

 Query_string_builder &dot() { returnput(".", 1); }

 Query_string_builder &put(constint64_t i) { returnput(to_string(i)); }
 Query_string_builder &put(constuint64_t u) { returnput(to_string(u)); }
 Query_string_builder &put(constint32_t i) { returnput(to_string(i)); }
 Query_string_builder &put(constuint32_t u) { returnput(to_string(u)); }
 Query_string_builder &put(constfloat f) { returnput(to_string(f)); }
 Query_string_builder &put(constdouble d) { returnput(to_string(d)); }

 Query_string_builder &put(constchar *s, size_t length);

 Query_formatter format();

 Query_string_builder &put(constchar *s) { returnput(s, strlen(s)); }

 Query_string_builder &put(const std::string &s) {
returnput(s.data(), s.length());
 }

 Query_string_builder &put(const ngs::PFS_string &s) {
returnput(s.data(), s.length());
 }

template <typename I>
 Query_string_builder &put_list(I begin, I end, const std::string &sep = ",") {
if (std::distance(begin, end) == 0) return *this;
put(*begin);
for (++begin; begin != end; ++begin) {
put(sep);
put(*begin);
 }
return *this;
 }

template <typename I, typename P>
 Query_string_builder &put_list(I begin, I end, P push,
const std::string &sep = ",") {
if (std::distance(begin, end) == 0) return *this;
push(*begin, this);
for (++begin; begin != end; ++begin) {
put(sep);
push(*begin, this);
 }
return *this;
 }

voidclear() { m_str.clear(); }

voidreserve(size_t bytes) { m_str.reserve(bytes); }

const ngs::PFS_string &get() const { return m_str; }

private:
 ngs::PFS_string m_str;
bool m_in_quoted;
bool m_in_identifier;

staticvoidinit_charset();
static std::once_flag m_charset_initialized;
static CHARSET_INFO *m_charset;
};

} // namespace xpl

#endif// PLUGIN_X_SRC_QUERY_STRING_BUILDER_H_