result.cc

/*
 * Copyright (c) 2015, 2024, 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.
 *
 * Without limiting anything contained in the foregoing, this file,
 * which is part of Connector/C++, is also subject to the
 * Universal FOSS Exception, version 1.0, a copy of which can be found at
 * https://oss.oracle.com/licenses/universal-foss-exception.
 *
 * 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
*/

#include<mysql/cdk.h>
#include<mysqlx/xdevapi.h>

#include"impl.h"

#include<vector>
#include<sstream>
#include<iomanip>
#include<cctype>


/*
 Implementation of Result and Row interfaces.
*/

usingnamespace ::mysqlx::impl::common;
usingnamespace ::mysqlx::internal;
usingnamespace ::mysqlx;

using std::endl;


classmysqlx::bytes::Access
{
public:
static bytes mk(const cdk::bytes &data)
 { returnbytes(data.begin(), data.end()); }
};


/*
 Column implementation.
*/


voidColumn_detail::print(std::ostream &out) const
{
if (!get_impl().m_schema_name.empty())
 out << "`" << get_impl().m_schema_name << "`.";
 string table_name = get_table_label();
if (!table_name.empty())
 out << "`" << table_name << "`.";
 out << "`" << get_label() <<"`";
}


/*
 Method getType() translates CDK type/format info into
 DevAPI type information.

 Note: Expected to return values of Type enum constants.
*/

Type get_api_type(cdk::Type_info, const Format_info &);

unsignedColumn_detail::get_type() const
{
returnunsigned(get_api_type(get_impl().m_type, get_impl()));
}


Type get_api_type(cdk::Type_info type, const Format_info &fmt)
{
switch (type)
 {
case cdk::TYPE_BYTES:
return Type::BYTES;

case cdk::TYPE_DOCUMENT:
return Type::JSON;

case cdk::TYPE_STRING:
 {
const Format_descr<cdk::TYPE_STRING> &fd
 = fmt.get<cdk::TYPE_STRING>();
if (fd.m_format.is_enum())
return Type::ENUM;
if (fd.m_format.is_set())
return Type::SET;
return Type::STRING;
 }

case cdk::TYPE_INTEGER:
 {
const Format_descr<cdk::TYPE_INTEGER> &fd
 = fmt.get<cdk::TYPE_INTEGER>();

if(fd.m_format.is_bit())
return Type::BIT;

size_t f_len = fd.m_format.length();

if (f_len < 5)
return Type::TINYINT;

if (f_len < 8)
return Type::SMALLINT;

if (f_len < 10)
return Type::MEDIUMINT;

if (f_len < 20)
return Type::INT;

return Type::BIGINT;
 }

case cdk::TYPE_FLOAT:
 {
const Format_descr<cdk::TYPE_FLOAT> &fd
 = fmt.get<cdk::TYPE_FLOAT>();
switch (fd.m_format.type())
 {
case cdk::Format<cdk::TYPE_FLOAT>::DOUBLE: return Type::DOUBLE;
case cdk::Format<cdk::TYPE_FLOAT>::FLOAT: return Type::FLOAT;
case cdk::Format<cdk::TYPE_FLOAT>::DECIMAL: return Type::DECIMAL;
default:
THROW("Unrecognized float value encoding format");
 }
 }

case cdk::TYPE_DATETIME:
 {
const Format_descr<cdk::TYPE_DATETIME> &fd
 = fmt.get<cdk::TYPE_DATETIME>();
switch (fd.m_format.type())
 {
case cdk::Format<cdk::TYPE_DATETIME>::TIME:
return Type::TIME;
case cdk::Format<cdk::TYPE_DATETIME>::TIMESTAMP:
return Type::TIMESTAMP;
case cdk::Format<cdk::TYPE_DATETIME>::DATETIME:
return fd.m_format.has_time() ? Type::DATETIME : Type::DATE;
default:
THROW("Unrecognized temporal value encoding format");
 }
 }

case cdk::TYPE_GEOMETRY:
return Type::GEOMETRY;

case cdk::TYPE_XML:
default: return Type::BYTES;
 }
}


mysqlx::string Column_detail::get_name() const
{
returnget_impl().m_name;
}

mysqlx::string Column_detail::get_label() const
{
returnget_impl().m_label;
}

mysqlx::string Column_detail::get_schema_name() const
{
returnget_impl().m_schema_name;
}

mysqlx::string Column_detail::get_table_name() const
{
returnget_impl().m_table_name;
}

mysqlx::string Column_detail::get_table_label() const
{
returnget_impl().m_table_label;
}

unsignedlongColumn_detail::get_length() const
{
returnget_impl().m_length;
}

unsignedshortColumn_detail::get_decimals() const
{
returnget_impl().m_decimals;
}


boolColumn_detail::is_signed() const
{
if (cdk::TYPE_INTEGER != get_impl().m_type)
returnfalse;

const Format_descr<cdk::TYPE_INTEGER> &fd
 = get_impl().get<cdk::TYPE_INTEGER>();
return !fd.m_format.is_unsigned();
}

boolColumn_detail::is_padded() const
{
returnget_impl().m_padded;
}


/*
 Handling character set and collation information
 -----------------------------------------------

 This information is obtained from format descriptor for columns of CDK
 STRING type. Format descriptor gives the MySQL collation id as given by
 the server. Function collation_from_charset_id() returns CollationInfo
 constant corresponding to given collation id. This CollationInfo instance
 can be then used to get collation name and the corresponding charcater
 set.
*/

#defineCS_SWITCH(CS) COLLATIONS_##CS(COLL_SWITCH)

#defineCOLL_SWITCH(CS,ID,COLL,CASE) \
case ID: return Collation<CharacterSet::CS>::COLL_CONST_NAME(COLL,CASE);

const CollationInfo& collation_from_id(cdk::collation_id_t id)
{
switch (id)
 {
CDK_CS_LIST(CS_SWITCH)
default:
THROW("Unknown collation id");
 }
}


const CollationInfo& Column_detail::get_collation() const
{
try {

switch (get_impl().m_type)
 {
case cdk::TYPE_BYTES:
return Collation<CharacterSet::binary>::bin;

case cdk::TYPE_DOCUMENT:
return Collation<CharacterSet::utf8mb3>::general_ci;

case cdk::TYPE_STRING:
 {
returncollation_from_id(get_impl().m_collation);
 }

case cdk::TYPE_INTEGER:
case cdk::TYPE_FLOAT:
case cdk::TYPE_DATETIME:
default:
THROW("No collation info for the type");
 }
 }
 CATCH_AND_WRAP
}

CharacterSet Column_detail::get_charset() const
{
// TODO: Better use cdk encoding format information
//const Format_descr<cdk::TYPE_STRING> &fd = m_impl->get<cdk::TYPE_STRING>();
returnget_collation().getCharacterSet();
}


/*
 Definitions of the CollationInfo constants describing all known collations
 as defined in mysqlx/collations.h.
*/

structCollationInfo::Access
{
enum coll_case {
 case_ci = CollationInfo::case_ci,
 case_ai_ci = case_ci,
 case_as_ci = case_ci,
 case_cs = CollationInfo::case_cs,
 case_as_cs = case_cs,
 case_as_cs_ks = case_cs,
 case_bin = CollationInfo::case_bin
 };

static CollationInfo mk(
 CharacterSet _cs, unsigned _id, coll_case _case, constchar *_name
 )
 {
 CollationInfo ci;
 ci.m_cs = _cs;
 ci.m_id = _id;
 ci.m_case = CollationInfo::coll_case(_case);
 ci.m_name = _name;
return ci;
 }
};


/*
 A helper function that reconstructs MySQL collation name from the data
 given by COLLATIONS_XXX() lists. In most cases the collation name is just
 a concatenation of charset name, collation and sensitivity flags - this
 default name is passed as 'name' pre-allocated string. But there are few
 exceptions to the general rule: 'name_bin' is the name to be used for binary
 collations; also, individual components of the name are given to allow
 further customization.
*/

constchar*
coll_name(
 std::string cs, std::string coll, std::string sensitivity,
constchar *name, constchar *name_bin)
{
static std::list<std::string> special;

/*
 For generic UCA collations, such as uca0900, the "uca" prefix is
 not present in the MySQL collation name. For example, for the uca0900
 collation with "ai_ci" sensitivity, the collation name
 is "utf8mb4_0900_ai_ci" but the value of 'name' is "utf8mb4_uca0900_ai_ci",
 so we need to correct this.
*/

if (coll.substr(0,3) == "uca")
 {
 special.push_back(cs + "_" + coll.substr(3) + "_" + sensitivity);
return special.back().c_str();
 }

if (sensitivity == "bin")
 {
// Note: special exception for "binary" collation (no _bin suffix)
return cs == "binary" ? "binary" : name_bin;
 }
else
return name;
}


#defineCOLL_DEFS(CS) COLLATIONS_##CS(COLL_CONST_DEF)

#defineCOLL_CONST_DEF(CS,ID,COLL,CASE) \
const CollationInfo \
Collation<CharacterSet::CS>::COLL_CONST_NAME(COLL,CASE) = \
CollationInfo::Access::mk(CharacterSet::CS, ID, \
 CollationInfo::Access::case_##CASE, \
COLL_NAME(CS,COLL,CASE));

#defineCOLL_NAME(CS,COLL,CASE) \
coll_name(#CS, #COLL, #CASE, #CS "_" #COLL "_" #CASE, #CS "_bin")

// Add utf8mb4 alias for bin collation for compatibility

#undef COLLATIONS_utf8mb4_EXTRA
#defineCOLLATIONS_utf8mb4_EXTRA \
const CollationInfo Collation<CharacterSet::utf8mb4>::utf8mb4 = \
 Collation<CharacterSet::utf8mb4>::bin;

CDK_CS_LIST(COLL_DEFS)

#undef COLLATIONS_utf8mb4_EXTRA
#defineCOLLATIONS_utf8mb4_EXTRA

/*
 Handling result data
 ====================
*/


/*
 Implementation of Row class
 ---------------------------
*/


Row_detail::Impl& Row_detail::get_impl()
{
if (!m_impl)
THROW("Attempt to use null Row instance");
return *m_impl;
}

voidRow_detail::ensure_impl()
{
if (!m_impl)
 m_impl = std::make_shared<Impl>();
}


/*
 Decoding document values from raw bytes representation.

 Note: Conversions for other value types are handled by common::Value
 class.
*/

mysqlx::Value
mysqlx::Value::Access::mk(cdk::bytes data, Format_descr<cdk::TYPE_DOCUMENT>&)
{
/*
 Note: this assumes that document is represented as json string
 - thanks to this we can take benefit of lazy parsing.

 Otherwise, implementation that would not assume what underlying
 representation is used for documnets should use a Codec to decode
 the raw bytes and build a representation of the documnent to be
 stored in the Value instance.
*/

// trim initial space

unsigned i;
for (i = 0; i < data.size() && std::isspace(*(data.begin() + i)); ++i);

 std::string json(data.begin() + i, data.end()-1);

if ('{' == *(data.begin() + i))
returnValue::Access::mk_doc(json);

returnValue::Access::mk_from_json(json);
}


mysqlx::col_count_tRow_detail::col_count() const
{
returnget_impl().col_count();
}


mysqlx::bytes Row_detail::get_bytes(mysqlx::col_count_t pos) const
{
 cdk::bytes data = get_impl().m_data.at(pos).data();
returnmysqlx::bytes::Access::mk(data);
}


mysqlx::Value& Row_detail::get_val(mysqlx::col_count_t pos)
{
returnget_impl().get(pos);
}


voidRow_detail::process_one(
 std::pair<Impl*, mysqlx::col_count_t> *data, const mysqlx::Value &val
)
{
 Impl *impl = data->first;
col_count_t pos = (data->second)++;
 impl->set(pos, val);
}


/*
 Result_detail
 =============
*/


Result_detail::Result_detail(Result_init &init)
{
 m_owns_impl = true;
 m_impl = newImpl(init);
}


Result_detail::~Result_detail() NOEXCEPT
{
try {
if (m_owns_impl)
delete m_impl;
 }
catch(...) {}
}


auto Result_detail::operator=(Result_detail &&other)
-> Result_detail&
{
if (m_impl && m_owns_impl)
delete m_impl;

 m_impl = other.m_impl;

if (!other.m_owns_impl)
 m_owns_impl = false;
else
 {
 m_owns_impl = true;
 other.m_owns_impl = false;
 }

return *this;
}


autoResult_detail::get_impl() -> Impl&
{
if (!m_impl)
THROW("Invalid result set");
return *m_impl;
}


voidResult_detail::check_result() const
{
if (!get_impl().has_data())
THROW("No result set");
}


unsigned
Result_detail::get_warning_count() const
{
returnget_impl().get_warning_count();
}


autoResult_detail::get_warning(size_t pos) -> Warning
{
if (!common::check_num_limits<unsigned>(pos))
throwstd::out_of_range("No diagnostic entry at position ...");

get_warning_count();
auto &impl = get_impl();
auto &it = impl.get_entries(cdk::api::Severity::WARNING);
size_t curr = SIZE_MAX;
while( curr != pos && it.next())
 {
 curr++;
 }

if (curr != pos || pos >= get_warning_count() )
throwstd::out_of_range("No diagnostic entry at position ...");

 byte level = Warning::LEVEL_ERROR;

switch (it.entry().severity())
 {
case cdk::api::Severity::ERROR: level = Warning::LEVEL_ERROR; break;
case cdk::api::Severity::WARNING: level = Warning::LEVEL_WARNING; break;
case cdk::api::Severity::INFO: level = Warning::LEVEL_INFO; break;
 }

// TODO: handle error category

returnWarning_detail(
 level,
 (uint16_t)it.entry().code().value(),
 it.entry().description()
 );
}


autoResult_detail::get_affected_rows() const -> uint64_t
{
returnget_impl().get_affected_rows();
}

autoResult_detail::get_auto_increment() const -> uint64_t
{
returnget_impl().get_auto_increment();
}


autoResult_detail::get_generated_ids() const -> DocIdList
{
returnget_impl().get_generated_ids();
}


boolResult_detail::has_data() const
{
returnget_impl().has_data();
}

boolResult_detail::next_result()
{
returnget_impl().next_result();
}


/*
 RowResult
 =========
*/


template<>
bool Row_result_detail<Columns>::iterator_next()
{
auto &impl = get_impl();
const Row_data *row = impl.get_row();

if (!row)
returnfalse;

 m_row = internal::Row_detail(
 std::make_shared<internal::Row_detail::Impl>(*row, impl.get_mdata())
 );

returntrue;
}


template<>
mysqlx::col_count_t Row_result_detail<Columns>::col_count() const
{
returnget_impl().get_col_count();
}


template<>
Row_result_detail<Columns>::Row_result_detail(Result_init &init)
 : Result_detail(init)
{
next_result();
}


template<>
auto Row_result_detail<Columns>::get_column(mysqlx::col_count_t pos) const
-> const Column&
{
return m_cols.at(pos);
}

template<>
auto Row_result_detail<Columns>::get_columns() const
-> const Columns&
{
return m_cols;
}


template<>
void Columns_detail<Column>::init(const Result_detail::Impl &impl)
{
clear();
for (col_count_t pos = 0; pos < impl.get_col_count(); ++pos)
 {
emplace_back(&impl.get_column(pos));
 }
}


template<>
mysqlx::row_count_t Row_result_detail<Columns>::row_count()
{
auto cnt = get_impl().count();
ASSERT_NUM_LIMITS(row_count_t, cnt);
return (row_count_t)cnt;
}


/*
 DocResult
 =========
*/


boolDoc_result_detail::iterator_next()
{
auto &impl = get_impl();
const Row_data *row = impl.get_row();

if (impl.entry_count())
 impl.get_error().rethrow();

if (!row)
returnfalse;

// @todo Avoid copying of document string.
 cdk::foundation::bytes data = row->at(0).data();
 m_cur_doc = DbDoc(std::string(data.begin(),data.end()-1));
returntrue;
}


uint64_tDoc_result_detail::count()
{
auto cnt = get_impl().count();
if (get_impl().entry_count() > 0)
get_impl().get_error().rethrow();
return cnt;
}