Analyzer Namespace Reference

Namespaces
	anonymous_namespace{Analyzer.cpp}

Classes
class	Expr
class	ColumnVar
class	ExpressionTuple
class	Var
class	Constant
class	UOper
class	BinOper
class	RangeOper
class	Subquery
class	InValues
class	InIntegerSet
class	MLPredictExpr
class	PCAProjectExpr
class	CharLengthExpr
class	KeyForStringExpr
class	SampleRatioExpr
class	CardinalityExpr
class	LikeExpr
class	RegexpExpr
class	WidthBucketExpr
class	LikelihoodExpr
class	AggExpr
class	CaseExpr
class	ExtractExpr
class	DateaddExpr
class	DatediffExpr
class	DatetruncExpr
class	StringOper
	Expression class for string functions The "arg" constructor parameter must be an expression that resolves to a string datatype (e.g. TEXT). More...
class	LowerStringOper
class	UpperStringOper
class	InitCapStringOper
class	ReverseStringOper
class	RepeatStringOper
class	ConcatStringOper
class	PadStringOper
class	TrimStringOper
class	SubstringStringOper
class	OverlayStringOper
class	ReplaceStringOper
class	SplitPartStringOper
class	RegexpReplaceStringOper
class	RegexpSubstrStringOper
class	RegexpCountStringOper
class	JsonValueStringOper
class	Base64EncodeStringOper
class	Base64DecodeStringOper
class	UrlEncodeStringOper
class	UrlDecodeStringOper
class	TryStringCastOper
class	PositionStringOper
class	JarowinklerSimilarityStringOper
class	LevenshteinDistanceStringOper
class	HashStringOper
class	FunctionOper
class	FunctionOperWithCustomTypeHandling
class	OffsetInFragment
struct	OrderEntry
class	WindowFrame
class	WindowFunction
class	ArrayExpr
class	GeoUOper
class	GeoBinOper
class	TargetEntry
class	Query
class	GeoExpr
class	GeoColumnVar
class	GeoConstant
class	GeoOperator
class	GeoTransformOperator
class	RangeTableEntry
class	Estimator
class	NDVEstimator
class	LargeNDVEstimator

Typedefs
using	LiteralArgMap = std::map< size_t, std::pair< SQLTypes, Datum >>
using	DomainSet = std::list< const Expr * >
using	ExpressionPtr = std::shared_ptr< Analyzer::Expr >
using	ExpressionPtrList = std::list< ExpressionPtr >
using	ExpressionPtrVector = std::vector< ExpressionPtr >

Functions
bool	Datum_equal (const SQLTypeInfo &ti, Datum val1, Datum val2)

Typedef Documentation

using Analyzer::DomainSet = typedef std::list<const Expr*>

Definition at line 62 of file Analyzer.h.

using Analyzer::ExpressionPtr = typedef std::shared_ptr<Analyzer::Expr>

Definition at line 184 of file Analyzer.h.

using Analyzer::ExpressionPtrList = typedef std::list<ExpressionPtr>

Definition at line 185 of file Analyzer.h.

using Analyzer::ExpressionPtrVector = typedef std::vector<ExpressionPtr>

Definition at line 186 of file Analyzer.h.

using Analyzer::LiteralArgMap = typedef std::map<size_t, std::pair<SQLTypes, Datum>>

Definition at line 4308 of file Analyzer.cpp.

Function Documentation

bool Analyzer::Datum_equal	(	const SQLTypeInfo &	ti,
		Datum	val1,
		Datum	val2
	)

Definition at line 2291 of file Analyzer.cpp.

References Datum::bigintval, Datum::boolval, Datum::doubleval, Datum::floatval, SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), Datum::intval, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, Datum::smallintval, Datum::stringval, Datum::tinyintval, and UNREACHABLE.

Referenced by Analyzer::Constant::operator==().

                                                                {
  switch (ti.get_type()) {
    case kBOOLEAN:
      return val1.boolval == val2.boolval;
    case kCHAR:
    case kVARCHAR:
    case kTEXT:
      return *val1.stringval == *val2.stringval;
    case kNUMERIC:
    case kDECIMAL:
    case kBIGINT:
      return val1.bigintval == val2.bigintval;
    case kINT:
      return val1.intval == val2.intval;
    case kSMALLINT:
      return val1.smallintval == val2.smallintval;
    case kTINYINT:
      return val1.tinyintval == val2.tinyintval;
    case kFLOAT:
      return val1.floatval == val2.floatval;
    case kDOUBLE:
      return val1.doubleval == val2.doubleval;
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
    case kINTERVAL_DAY_TIME:
    case kINTERVAL_YEAR_MONTH:
      return val1.bigintval == val2.bigintval;
    case kPOINT:
    case kMULTIPOINT:
    case kLINESTRING:
    case kMULTILINESTRING:
    case kPOLYGON:
    case kMULTIPOLYGON:
      return *val1.stringval == *val2.stringval;
    default:
      throw std::runtime_error("Unrecognized type for Constant Datum equality: " +
                               ti.get_type_name());
  }
  UNREACHABLE();
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function: