database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-07-05 15:41:14 +03:00
Code Activity
Files
c97e58c9b51aab2667b5c98d4d810ff76d9dfafa
mariadb-columnstore-engine/dbcon/execplan/predicateoperator.h
Andrew Hutchings 70b3aa3159 Merge branch 'develop-1.2' into develop-merge-up-20190924-2
2019-09-24 14:17:57 +01:00

620 lines
18 KiB
C++
Raw Blame History

/* Copyright (C) 2014 InfiniDB, Inc.
Copyright (C) 2019 MariaDB Corporation
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of
the License.
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 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 Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
/***********************************************************************
* $Id: predicateoperator.h 9667 2013-07-08 16:37:10Z bpaul $
*
*
***********************************************************************/
/** @file */
#ifndef PREDICATEOPERATOR_H
#define PREDICATEOPERATOR_H
#include <string>
#include <sstream>
#if defined(_MSC_VER)
#include <malloc.h>
#elif defined(__FreeBSD__)
#include <cstdlib>
#else
#include <alloca.h>
#endif
#include <cstring>
#include <cmath>
#include <boost/regex.hpp>
#include "expressionparser.h"
#include "returnedcolumn.h"
#include "dataconvert.h"
#include "utils_utf8.h"
namespace messageqcpp
{
class ByteStream;
}
namespace execplan
{
class PredicateOperator : public Operator
{
public:
PredicateOperator();
PredicateOperator(const std::string& operatorName);
PredicateOperator(const PredicateOperator& rhs);
virtual ~PredicateOperator();
/** return a copy of this pointer
*
* deep copy of this pointer and return the copy
*/
inline virtual PredicateOperator* clone() const
{
return new PredicateOperator (*this);
}
/**
* The serialization interface
*/
virtual void serialize(messageqcpp::ByteStream&) const;
virtual void unserialize(messageqcpp::ByteStream&);
/** @brief Do a deep, strict (as opposed to semantic) equivalence test
*
* Do a deep, strict (as opposed to semantic) equivalence test.
* @return true iff every member of t is a duplicate copy of every member of this; false otherwise
*/
virtual bool operator==(const TreeNode* t) const;
/** @brief Do a deep, strict (as opposed to semantic) equivalence test
*
* Do a deep, strict (as opposed to semantic) equivalence test.
* @return true iff every member of t is a duplicate copy of every member of this; false otherwise
*/
bool operator==(const PredicateOperator& t) const;
/** @brief Do a deep, strict (as opposed to semantic) equivalence test
*
* Do a deep, strict (as opposed to semantic) equivalence test.
* @return false iff every member of t is a duplicate copy of every member of this; true otherwise
*/
virtual bool operator!=(const TreeNode* t) const;
/** @brief Do a deep, strict (as opposed to semantic) equivalence test
*
* Do a deep, strict (as opposed to semantic) equivalence test.
* @return false iff every member of t is a duplicate copy of every member of this; true otherwise
*/
bool operator!=(const PredicateOperator& t) const;
/***********************************************************
* F&E framework *
***********************************************************/
inline virtual bool getBoolVal(rowgroup::Row& row, bool& isNull, ReturnedColumn* lop, ReturnedColumn* rop);
void setOpType(Type& l, Type& r);
private:
template <typename result_t>
inline bool numericCompare(result_t op1, result_t op2);
inline bool strCompare(const std::string& op1, const std::string& op2);
// MCOL-1559
inline bool strTrimCompare(const std::string& op1, const std::string& op2);
};
inline bool PredicateOperator::getBoolVal(rowgroup::Row& row, bool& isNull, ReturnedColumn* lop, ReturnedColumn* rop)
{
// like operator. both sides are string.
if (fOp == OP_LIKE || fOp == OP_NOTLIKE)
{
SP_CNX_Regex regex = rop->regex();
// Ugh. The strings returned by getStrVal have null padding out to the col width. boost::regex
// considers these nulls significant, but they're not in the pattern, so we need to strip
// them off...
const std::string& v = lop->getStrVal(row, isNull);
// char* c = (char*)alloca(v.length() + 1);
// memcpy(c, v.c_str(), v.length());
// c[v.length()] = 0;
// std::string vv(c);
if (regex)
{
#ifdef POSIX_REGEX
bool ret = regexec(regex.get(), v.c_str(), 0, NULL, 0) == 0;
#else
bool ret = boost::regex_match(v.c_str(), *regex);
#endif
return (((fOp == OP_LIKE) ? ret : !ret) && !isNull);
}
else
{
#ifdef POSIX_REGEX
regex_t regex;
std::string str = dataconvert::DataConvert::constructRegexp(rop->getStrVal(row, isNull));
regcomp(&regex, str.c_str(), REG_NOSUB | REG_EXTENDED);
bool ret = regexec(&regex, v.c_str(), 0, NULL, 0) == 0;
regfree(&regex);
#else
boost::regex regex(dataconvert::DataConvert::constructRegexp(rop->getStrVal(row, isNull)));
bool ret = boost::regex_match(v.c_str(), regex);
#endif
return (((fOp == OP_LIKE) ? ret : !ret) && !isNull);
}
}
// fOpType should have already been set on the connector during parsing
switch (fOperationType.colDataType)
{
case execplan::CalpontSystemCatalog::BIGINT:
case execplan::CalpontSystemCatalog::INT:
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::TINYINT:
case execplan::CalpontSystemCatalog::SMALLINT:
{
if (fOp == OP_ISNULL)
{
lop->getIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
int64_t val1 = lop->getIntVal(row, isNull);
if (isNull)
return false;
return numericCompare(val1, rop->getIntVal(row, isNull)) && !isNull;
}
case execplan::CalpontSystemCatalog::UBIGINT:
case execplan::CalpontSystemCatalog::UINT:
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UTINYINT:
case execplan::CalpontSystemCatalog::USMALLINT:
{
if (fOp == OP_ISNULL)
{
lop->getUintVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getUintVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
uint64_t val1 = lop->getUintVal(row, isNull);
if (isNull)
return false;
return numericCompare(val1, rop->getUintVal(row, isNull)) && !isNull;
}
case execplan::CalpontSystemCatalog::FLOAT:
case execplan::CalpontSystemCatalog::UFLOAT:
case execplan::CalpontSystemCatalog::DOUBLE:
case execplan::CalpontSystemCatalog::UDOUBLE:
{
if (fOp == OP_ISNULL)
{
lop->getDoubleVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getDoubleVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
double val1 = lop->getDoubleVal(row, isNull);
if (isNull)
return false;
return numericCompare(val1, rop->getDoubleVal(row, isNull)) && !isNull;
}
case execplan::CalpontSystemCatalog::LONGDOUBLE:
{
if (fOp == OP_ISNULL)
{
lop->getLongDoubleVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getLongDoubleVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
long double val1 = lop->getLongDoubleVal(row, isNull);
if (isNull)
return false;
long double val2 = rop->getLongDoubleVal(row, isNull);
if (isNull)
return false;
// In many case, rounding error will prevent an eq compare to work
// In these cases, use the largest scale of the two items.
if (fOp == execplan::OP_EQ)
{
// In case a val is a representation of a very large integer,
// we won't want to just multiply by scale, as it may move
// significant digits out of scope. So we break them apart
// and compare each separately
int64_t scale = std::max(lop->resultType().scale, rop->resultType().scale);
if (scale)
{
long double intpart1;
long double fract1 = modfl(val1, &intpart1);
long double intpart2;
long double fract2 = modfl(val2, &intpart2);
if (numericCompare(intpart1, intpart2))
{
double factor = pow(10.0, (double)scale);
fract1 = roundl(fract1 * factor);
fract2 = roundl(fract2 * factor);
return numericCompare(fract1, fract2);
}
else
{
return false;
}
}
}
return numericCompare(val1, val2);
}
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
{
if (fOp == OP_ISNULL)
{
lop->getDecimalVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getDecimalVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
IDB_Decimal val1 = lop->getDecimalVal(row, isNull);
if (isNull)
return false;
return numericCompare(val1, rop->getDecimalVal(row, isNull)) && !isNull;
}
case execplan::CalpontSystemCatalog::DATE:
{
if (fOp == OP_ISNULL)
{
lop->getDateIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getDateIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
int64_t val1 = lop->getDateIntVal(row, isNull);
if (isNull)
return false;
return numericCompare(val1, (int64_t)rop->getDateIntVal(row, isNull)) && !isNull;
}
case execplan::CalpontSystemCatalog::DATETIME:
{
if (fOp == OP_ISNULL)
{
lop->getDatetimeIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getDatetimeIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
int64_t val1 = lop->getDatetimeIntVal(row, isNull);
if (isNull)
return false;
return numericCompare(val1, rop->getDatetimeIntVal(row, isNull)) && !isNull;
}
case execplan::CalpontSystemCatalog::TIMESTAMP:
{
if (fOp == OP_ISNULL)
{
lop->getTimestampIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getTimestampIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
int64_t val1 = lop->getTimestampIntVal(row, isNull);
if (isNull)
return false;
return numericCompare(val1, rop->getTimestampIntVal(row, isNull)) && !isNull;
}
case execplan::CalpontSystemCatalog::TIME:
{
if (fOp == OP_ISNULL)
{
lop->getTimeIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getTimeIntVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
int64_t val1 = lop->getTimeIntVal(row, isNull);
if (isNull)
return false;
return numericCompare(val1, rop->getTimeIntVal(row, isNull)) && !isNull;
}
case execplan::CalpontSystemCatalog::VARCHAR:
case execplan::CalpontSystemCatalog::CHAR:
case execplan::CalpontSystemCatalog::TEXT:
{
if (fOp == OP_ISNULL)
{
lop->getStrVal(row, isNull);
bool ret = isNull;
isNull = false;
return ret;
}
if (fOp == OP_ISNOTNULL)
{
lop->getStrVal(row, isNull);
bool ret = isNull;
isNull = false;
return !ret;
}
if (isNull)
return false;
const std::string& val1 = lop->getStrVal(row, isNull);
if (isNull)
return false;
return strTrimCompare(val1, rop->getStrVal(row, isNull)) && !isNull;
// return strCompare(val1, rop->getStrVal(row, isNull)) && !isNull;
}
//FIXME: ???
case execplan::CalpontSystemCatalog::VARBINARY:
case execplan::CalpontSystemCatalog::BLOB:
return false;
break;
default:
{
std::ostringstream oss;
oss << "invalid predicate operation type: " << fOperationType.colDataType;
throw logging::InvalidOperationExcept(oss.str());
}
}
return false;
}
template <typename result_t>
inline bool PredicateOperator::numericCompare(result_t op1, result_t op2)
{
switch (fOp)
{
case OP_EQ:
return op1 == op2;
case OP_NE:
return op1 != op2;
case OP_GT:
return op1 > op2;
case OP_GE:
return op1 >= op2;
case OP_LT:
return op1 < op2;
case OP_LE:
return op1 <= op2;
default:
{
std::ostringstream oss;
oss << "invalid predicate operation: " << fOp;
throw logging::InvalidOperationExcept(oss.str());
}
}
}
inline bool PredicateOperator::strCompare(const std::string& op1, const std::string& op2)
{
switch (fOp)
{
case OP_EQ:
return funcexp::utf8::idb_strcoll(op1.c_str(), op2.c_str()) == 0;
case OP_NE:
return funcexp::utf8::idb_strcoll(op1.c_str(), op2.c_str()) != 0;
case OP_GT:
return funcexp::utf8::idb_strcoll(op1.c_str(), op2.c_str()) > 0;
case OP_GE:
return funcexp::utf8::idb_strcoll(op1.c_str(), op2.c_str()) >= 0;
case OP_LT:
return funcexp::utf8::idb_strcoll(op1.c_str(), op2.c_str()) < 0;
case OP_LE:
return funcexp::utf8::idb_strcoll(op1.c_str(), op2.c_str()) <= 0;
default:
{
std::ostringstream oss;
oss << "Non support predicate operation: " << fOp;
throw logging::InvalidOperationExcept(oss.str());
}
}
}
inline bool PredicateOperator::strTrimCompare(const std::string& op1, const std::string& op2)
{
switch (fOp)
{
case OP_EQ:
return funcexp::utf8::idb_strtrimcoll(op1, op2) == 0;
case OP_NE:
return funcexp::utf8::idb_strtrimcoll(op1, op2) != 0;
case OP_GT:
return funcexp::utf8::idb_strtrimcoll(op1, op2) > 0;
case OP_GE:
return funcexp::utf8::idb_strtrimcoll(op1, op2) >= 0;
case OP_LT:
return funcexp::utf8::idb_strtrimcoll(op1, op2) < 0;
case OP_LE:
return funcexp::utf8::idb_strtrimcoll(op1, op2) <= 0;
default:
{
std::ostringstream oss;
oss << "Non support predicate operation: " << fOp;
throw logging::InvalidOperationExcept(oss.str());
}
}
}
std::ostream& operator<<(std::ostream& os, const PredicateOperator& rhs);
}
#endif //PREDICATEOPERATOR_H
View Git Blame Copy Permalink