database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-04-18 21:44:02 +03:00
Code
mariadb-columnstore-engine/dbcon/mysql/ha_window_function.cpp
Alexander Barkov 9608533d92 MCOL-4734 Compilation failure: MariaDB-10.6 + ColumnStore-develop 
mcsconfig.h and my_config.h have the following
pre-processor definitions:

1. Conflicting definitions coming from the standard cmake definitions:
- PACKAGE
- PACKAGE_BUGREPORT
- PACKAGE_NAME
- PACKAGE_STRING
- PACKAGE_TARNAME
- PACKAGE_VERSION
- VERSION

2. Conflicting definitions of other kinds:
- HAVE_STRTOLL - this is a dirt in MariaDB headers.
  Should be fixed in the server code. my_config.h erroneously
  performs "#define HAVE_STRTOLL" instead of "#define HAVE_STRTOLL 1".
  in some cases. The former is not CMake compatible style. The latter is.

3. Non-conflicting definitions:
  Otherwise, mcsconfig.h and my_config.h should be mutually compatible,
  because both are generated by cmake on the same host machine. So
  they should have exactly equal definitions like "HAVE_XXX", "SIZEOF_XXX", etc.

Observations:
- It's OK to include both mcsconfig.h and my_config.h providing that we
  suppress duplicate definition of the above conflicting types #1 and #2.
- There is no a need to suppress duplicate definitions mentioned in #3,
  as they are compatible!
- my_sys.h and m_ctype.h must always follow a CMake configuation header,
  either my_config.h or mcsconfig.h (or both).
  They must never be included without any preceeding configuration header.

This change make sure that we resolve conflicts by:
- either disallowing inclusion of mcsconfig.h and my_config.h
  at the same time
- or by hiding conflicting definitions #1 and #2
  (with their later restoring).
- also, by making sure that my_sys.h and m_ctype.h always follow
  a CMake configuration file.

Details:
- idb_mysql.h can now only be included only after my_config.h
  An attempt to use idb_mysql.h with mcsconfig.h instead of
  my_config.h is caught by the "#error" preprocessor directive.

- mariadb_my_sys.h can now be only included after mcsconfig.h.
  An attempt to use mariadb_my_sys.h without mcscofig.h
  (e.g. with my_config.h) is also caught by "#error".

- collation.h now can now be included in two ways.
  It now has the following effective structure:

    #if defined(PREFER_MY_CONFIG_H) && defined(MY_CONFIG_H)
    //  Remember current conflicting definitions on the preprocessor stack
    //  Undefine current conflicting definitions
    #endif
    #include "mcsconfig.h"
    #include "m_ctype.h"
    #if defined(PREFER_MY_CONFIG_H) && defined(MY_CONFIG_H)
    #    Restore conflicting definitions from the preprocessor stack
    #endif

  and can be included as follows:

  a. using only mcsconfig.h as a configuration header:

    // my_config.h must not be included so far
    #include "collation.h"

  b. using my_config.h as the first included configuration file:

    #define PREFER_MY_CONFIG_H // Force conflict resolution
    #include "my_config.h"     // can be included directly or indirectly
    ...
    #include "collation.h"

Other changes:

- Adding helper header files
     utils/common/mcsconfig_conflicting_defs_remember.h
     utils/common/mcsconfig_conflicting_defs_restore.h
     utils/common/mcsconfig_conflicting_defs_undef.h
  to perform conflict resolution easier.

- Removing `#include "collation.h"` from a number of files,
  as it's automatically included from rowgroup.h.

- Removing redundant `#include "utils_utf8.h"`.
  This change is not directly related to the problem being fixed,
  but it's nice to remove redundant directives for both collation.h
  and utils_utf8.h from all the files that do not really need them.
  (this change could probably have gone as a separate commit)

- Changing my_init() to MY_INIT(argv[0]) in the MCS services sources.
  After the fix of the complitation failure it appeared that ColumnStore
  services compiled with the debug build crash due to recent changes in
  safemalloc. The crash happened in strcmp() with `my_progname` as an argument
  (where my_progname is a mysys global variable). This problem should
  probably be fixed on the server side as well to avoid passing NULL.
  But, the majority of MariaDB executable programs also use MY_INIT(argv[0])
  rather than my_init(). So let's make MCS do like the other programs do.
2021-05-25 12:34:36 +04:00

953 lines
34 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: ha_window_function.cpp 9586 2013-05-31 22:02:06Z zzhu $
*
*
***********************************************************************/
#define PREFER_MY_CONFIG_H
#include <my_config.h>
#include <iostream>
#include <string>
using namespace std;
#include "idb_mysql.h"
#include "ha_mcs_impl_if.h"
#include "ha_mcs_sysvars.h"
#include "arithmeticcolumn.h"
#include "arithmeticoperator.h"
#include "constantcolumn.h"
#include "functioncolumn.h"
#include "intervalcolumn.h"
#include "windowfunctioncolumn.h"
using namespace execplan;
#include "idberrorinfo.h"
#include "errorids.h"
using namespace logging;
#include "functor.h"
#include "funcexp.h"
using namespace funcexp;
#include "mcsv1_udaf.h"
using namespace mcsv1sdk;
#include "vlarray.h"
namespace cal_impl_if
{
ReturnedColumn* nullOnError(gp_walk_info& gwi)
{
if (gwi.hasSubSelect)
{
gwi.parseErrorText = logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_NON_SUPPORT_SELECT_SUB);
setError(gwi.thd, ER_CHECK_NOT_IMPLEMENTED, gwi.parseErrorText);
}
if (gwi.parseErrorText.empty())
{
gwi.parseErrorText = logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_NON_SUPPORT);
setError(gwi.thd, ER_CHECK_NOT_IMPLEMENTED, gwi.parseErrorText);
}
return NULL;
}
WF_FRAME frame(Window_frame_bound::Bound_precedence_type bound, Item* offset)
{
switch (bound)
{
case Window_frame_bound::PRECEDING:
if (offset)
return WF_PRECEDING;
else
return WF_UNBOUNDED_PRECEDING;
case Window_frame_bound::FOLLOWING:
if (offset)
return WF_FOLLOWING;
else
return WF_UNBOUNDED_FOLLOWING;
case Window_frame_bound::CURRENT: // Offset is meaningless
return WF_CURRENT_ROW;
default:
return WF_UNKNOWN;
}
}
ReturnedColumn* buildBoundExp(WF_Boundary& bound, SRCP& order, gp_walk_info& gwi)
{
if (get_fe_conn_info_ptr() == NULL)
set_fe_conn_info_ptr((void*)new cal_connection_info());
cal_connection_info* ci = reinterpret_cast<cal_connection_info*>(get_fe_conn_info_ptr());
bool addOp = true;
ReturnedColumn* rc = NULL;
if (bound.fFrame == execplan::WF_PRECEDING)
{
if (order->asc())
addOp = false;
}
else if (!order->asc()) // must be WF_FOLLOWING
addOp = false;
funcexp::FunctionParm funcParms;
SPTP sptp;
IntervalColumn* intervalCol = dynamic_cast<IntervalColumn*>(bound.fVal.get());
// @todo error out non constant. only support literal interval for now.
if (!intervalCol && order->resultType().colDataType == CalpontSystemCatalog::DATE)
{
intervalCol = new IntervalColumn(bound.fVal, (int)IntervalColumn::INTERVAL_DAY);
bound.fVal.reset(intervalCol);
}
if (intervalCol)
{
// date_add
rc = new FunctionColumn();
string funcName = "date_add_interval";
// @bug6061 . YEAR, QUARTER, MONTH, WEEK, DAY type
CalpontSystemCatalog::ColType ct;
if (order->resultType().colDataType == CalpontSystemCatalog::DATE &&
intervalCol->intervalType() <= IntervalColumn::INTERVAL_DAY)
{
ct.colDataType = CalpontSystemCatalog::DATE;
ct.colWidth = 4;
}
else
{
ct.colDataType = CalpontSystemCatalog::DATETIME;
ct.colWidth = 8;
}
// put interval val column to bound
(dynamic_cast<FunctionColumn*>(rc))->functionName(funcName);
(dynamic_cast<FunctionColumn*>(rc))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
sptp.reset(new ParseTree(order->clone()));
funcParms.push_back(sptp);
sptp.reset(new ParseTree(intervalCol->val()->clone()));
funcParms.push_back(sptp);
funcParms.push_back(getIntervalType(gwi.thd, intervalCol->intervalType()));
SRCP srcp(intervalCol->val());
bound.fVal = srcp;
if (addOp)
{
sptp.reset(new ParseTree(new ConstantColumn("ADD")));
(dynamic_cast<ConstantColumn*>(sptp->data()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(sptp);
}
else
{
sptp.reset(new ParseTree(new ConstantColumn("SUB")));
(dynamic_cast<ConstantColumn*>(sptp->data()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(sptp);
}
(dynamic_cast<FunctionColumn*>(rc))->functionParms(funcParms);
rc->resultType(ct);
// @bug6061. Use result type as operation type for WF bound expression
rc->operationType(ct);
rc->expressionId(ci->expressionId++);
return rc;
}
// arithmetic
rc = new ArithmeticColumn();
ArithmeticOperator* aop;
if (addOp)
aop = new ArithmeticOperator("+");
else
aop = new ArithmeticOperator("-");
aop->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
ParseTree* pt = new ParseTree(aop);
ParseTree* lhs = 0, *rhs = 0;
lhs = new ParseTree(order->clone());
rhs = new ParseTree(bound.fVal->clone());
pt->left(lhs);
pt->right(rhs);
aop->resultType(order->resultType());
aop->operationType(aop->resultType());
(dynamic_cast<ArithmeticColumn*>(rc))->expression(pt);
rc->resultType(aop->resultType());
rc->operationType(aop->operationType());
rc->expressionId(ci->expressionId++);
return rc;
}
// Since columnstore implemented Windows Functions before MariaDB, we need
// map from the enum MariaDB uses to the string that columnstore uses to
// identify the function type.
string ConvertFuncName(Item_sum* item)
{
switch (item->sum_func())
{
case Item_sum::COUNT_FUNC:
if (!item->arguments()[0]->name.str)
return "COUNT(*)";
return "COUNT";
break;
case Item_sum::COUNT_DISTINCT_FUNC:
return "COUNT_DISTINCT";
break;
case Item_sum::SUM_FUNC:
return "SUM";
break;
case Item_sum::SUM_DISTINCT_FUNC:
return "SUM_DISTINCT";
break;
case Item_sum::AVG_FUNC:
return "AVG";
break;
case Item_sum::AVG_DISTINCT_FUNC:
return "AVG_DISTINCT";
break;
case Item_sum::MIN_FUNC:
return "MIN";
break;
case Item_sum::MAX_FUNC:
return "MAX";
break;
case Item_sum::STD_FUNC:
if (((Item_sum_variance*)item)->sample)
return "STDDEV_SAMP";
else
return "STDDEV_POP";
break;
case Item_sum::VARIANCE_FUNC:
if (((Item_sum_variance*)item)->sample)
return "VAR_SAMP";
else
return "VAR_POP";
break;
case Item_sum::SUM_BIT_FUNC:
if (strcmp(item->func_name(), "bit_or(") == 0)
return "BIT_OR";
if (strcmp(item->func_name(), "bit_and(") == 0)
return "BIT_AND";
if (strcmp(item->func_name(), "bit_xor(") == 0)
return "BIT_XOR";
break;
case Item_sum::UDF_SUM_FUNC:
return "UDAF_FUNC";
break;
case Item_sum::GROUP_CONCAT_FUNC:
return "GROUP_CONCAT"; // Not supported
break;
case Item_sum::ROW_NUMBER_FUNC:
return "ROW_NUMBER";
break;
case Item_sum::RANK_FUNC:
return "RANK";
break;
case Item_sum::DENSE_RANK_FUNC:
return "DENSE_RANK";
break;
case Item_sum::PERCENT_RANK_FUNC:
return "PERCENT_RANK";
break;
case Item_sum::PERCENTILE_CONT_FUNC:
return "PERCENTILE_CONT";
break;
case Item_sum::PERCENTILE_DISC_FUNC:
return "PERCENTILE_DISC";
case Item_sum::CUME_DIST_FUNC:
return "CUME_DIST";
break;
case Item_sum::NTILE_FUNC:
return "NTILE";
break;
case Item_sum::FIRST_VALUE_FUNC:
return "FIRST_VALUE";
break;
case Item_sum::LAST_VALUE_FUNC:
return "LAST_VALUE";
break;
case Item_sum::NTH_VALUE_FUNC:
return "NTH_VALUE";
break;
case Item_sum::LEAD_FUNC:
return "LEAD";
break;
case Item_sum::LAG_FUNC:
return "LAG";
break;
default:
// We just don't handle it.
break;
};
return "";
}
ReturnedColumn* buildWindowFunctionColumn(Item* item, gp_walk_info& gwi, bool& nonSupport)
{
//@todo fix print for create view
//String str;
//item->print(&str, QT_INFINIDB_NO_QUOTE);
//cout << str.c_ptr() << endl;
if (get_fe_conn_info_ptr() == NULL)
set_fe_conn_info_ptr((void*)new cal_connection_info());
cal_connection_info* ci = reinterpret_cast<cal_connection_info*>(get_fe_conn_info_ptr());
gwi.hasWindowFunc = true;
Item_window_func* wf = (Item_window_func*)item;
Item_sum* item_sum = wf->window_func();
string funcName = ConvertFuncName(item_sum);
WindowFunctionColumn* ac = new WindowFunctionColumn(funcName);
ac->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
ac->distinct(item_sum->has_with_distinct());
Window_spec* win_spec = wf->window_spec;
SRCP srcp;
CalpontSystemCatalog::ColType ct; // For return type
// arguments
vector<SRCP> funcParms;
for (uint32_t i = 0; i < item_sum->argument_count(); i++)
{
srcp.reset(buildReturnedColumn((item_sum->arguments()[i]), gwi, nonSupport));
if (!srcp)
return nullOnError(gwi);
funcParms.push_back(srcp);
if (gwi.clauseType == WHERE && !gwi.rcWorkStack.empty())
gwi.rcWorkStack.pop();
}
// Setup UDAnF functions
if (item_sum->sum_func() == Item_sum::UDF_SUM_FUNC)
{
Item_udf_sum* udfsum = (Item_udf_sum*)item_sum;
mcsv1sdk::mcsv1Context& context = ac->getUDAFContext();
context.setName(udfsum->func_name());
// Set up the return type defaults for the call to init()
execplan::CalpontSystemCatalog::ColType& rt = ac->resultType();
context.setResultType(rt.colDataType);
context.setColWidth(rt.colWidth);
context.setScale(rt.scale);
context.setPrecision(rt.precision);
context.setParamCount(funcParms.size());
utils::VLArray<mcsv1sdk::ColumnDatum> colTypes(funcParms.size());
// Turn on the Analytic flag so the function is aware it is being called
// as a Window Function.
context.setContextFlag(CONTEXT_IS_ANALYTIC);
// Build the column type vector.
// Modified for MCOL-1201 multi-argument aggregate
for (size_t i = 0; i < funcParms.size(); ++i)
{
const execplan::CalpontSystemCatalog::ColType& resultType
= funcParms[i]->resultType();
mcsv1sdk::ColumnDatum& colType = colTypes[i];
colType.dataType = resultType.colDataType;
colType.precision = resultType.precision;
colType.scale = resultType.scale;
colType.charsetNumber = resultType.charsetNumber;
}
// Call the user supplied init()
if (context.getFunction()->init(&context, colTypes) == mcsv1_UDAF::ERROR)
{
gwi.fatalParseError = true;
gwi.parseErrorText = context.getErrorMessage();
return NULL;
}
if (!context.getRunFlag(UDAF_OVER_REQUIRED) && !context.getRunFlag(UDAF_OVER_ALLOWED))
{
gwi.parseErrorText =
logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_UDANF_NOT_ALLOWED,
context.getName());
return nullOnError(gwi);
}
// Set the return type as set in init()
ct.colDataType = context.getResultType();
ct.colWidth = context.getColWidth();
ct.scale = context.getScale();
ct.precision = context.getPrecision();
ac->resultType(ct);
}
// Some functions, such as LEAD/LAG don't have all parameters implemented in the
// front end. Add dummies here to make the backend use defaults.
// Some of these will be temporary until they are implemented in the front end.
// Others need to stay because the back end expects them, but the front end
// no longer sends them.
// This case is kept in enum order in hopes the compiler can optimize
switch (item_sum->sum_func())
{
case Item_sum::UDF_SUM_FUNC:
{
unsigned long bRespectNulls = (ac->getUDAFContext().getRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS)) ? 0 : 1;
char sRespectNulls[18];
sprintf(sRespectNulls, "%lu", bRespectNulls);
srcp.reset(new ConstantColumn(sRespectNulls, (uint64_t)bRespectNulls, ConstantColumn::NUM)); // IGNORE/RESPECT NULLS. 1 => RESPECT
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
break;
}
case Item_sum::FIRST_VALUE_FUNC:
srcp.reset(new ConstantColumn("1", (uint64_t)1, ConstantColumn::NUM)); // OFFSET (always one)
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
srcp.reset(new ConstantColumn("1", (uint64_t)1, ConstantColumn::NUM)); // FROM_FIRST
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
srcp.reset(new ConstantColumn("1", (uint64_t)1, ConstantColumn::NUM)); // IGNORE/RESPECT NULLS. 1 => RESPECT
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
break;
case Item_sum::LAST_VALUE_FUNC:
srcp.reset(new ConstantColumn("1", (uint64_t)1, ConstantColumn::NUM)); // OFFSET (always one)
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
srcp.reset(new ConstantColumn("0", (uint64_t)0, ConstantColumn::NUM)); // FROM_LAST
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
srcp.reset(new ConstantColumn("1", (uint64_t)1, ConstantColumn::NUM)); // IGNORE/RESPECT NULLS. 1 => RESPECT
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
break;
case Item_sum::NTH_VALUE_FUNC:
// When the front end supports these paramters, this needs modification
srcp.reset(new ConstantColumn("1", (uint64_t)1, ConstantColumn::NUM)); // FROM FIRST/LAST 1 => FIRST
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
srcp.reset(new ConstantColumn("1", (uint64_t)1, ConstantColumn::NUM)); // IGNORE/RESPECT NULLS. 1 => RESPECT
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
break;
case Item_sum::LEAD_FUNC:
case Item_sum::LAG_FUNC:
// When the front end supports these paramters, this needs modification
srcp.reset(new ConstantColumn("", ConstantColumn::NULLDATA)); // Default to fill in for NULL values
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
srcp.reset(new ConstantColumn("1", (uint64_t)1, ConstantColumn::NUM)); // IGNORE/RESPECT NULLS. 1 => RESPECT
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
funcParms.push_back(srcp);
break;
default:
break;
};
ac->functionParms(funcParms);
// Partition by
if (win_spec)
{
vector<SRCP> partitions;
for (ORDER* ord = win_spec->partition_list->first; ord; ord = ord->next)
{
srcp.reset(buildReturnedColumn(*ord->item, gwi, nonSupport));
if (!srcp)
return nullOnError(gwi);
partitions.push_back(srcp);
}
ac->partitions(partitions);
// Order by
WF_OrderBy orderBy;
// order columns
if (win_spec->order_list)
{
// It is an error to have an order by clause if a UDAnF says it shouldn't
if (item_sum->sum_func() == Item_sum::UDF_SUM_FUNC)
{
mcsv1sdk::mcsv1Context& context = ac->getUDAFContext();
if (!context.getRunFlag(UDAF_ORDER_ALLOWED))
{
gwi.parseErrorText =
logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_UDANF_ORDER_NOT_ALLOWED,
context.getName());
return nullOnError(gwi);
}
}
vector<SRCP> orders;
ORDER* orderCol = reinterpret_cast<ORDER*>(win_spec->order_list->first);
for (; orderCol; orderCol = orderCol->next)
{
Item* orderItem = *(orderCol->item);
srcp.reset(buildReturnedColumn(orderItem, gwi, nonSupport));
// MCOL-1052 GROUP BY handler has all of query's agg Items
// as field and correlates them with its extended SELECT Items.
if (!srcp)
{
orderItem = orderCol->item_ptr;
if (orderItem)
{
gwi.fatalParseError = false;
srcp.reset(buildReturnedColumn(orderItem, gwi, nonSupport));
}
}
if (!srcp)
return nullOnError(gwi);
srcp->asc(orderCol->direction == ORDER::ORDER_ASC ? true : false);
// srcp->nullsFirst(orderCol->nulls); // nulls 2-default, 1-nulls first, 0-nulls last
srcp->nullsFirst(orderCol->direction == ORDER::ORDER_ASC ? 1 : 0); // WINDOWS TODO: implement NULLS FIRST/LAST in 10.2 front end
orders.push_back(srcp);
}
orderBy.fOrders = orders;
}
else
{
if (item_sum->sum_func() == Item_sum::UDF_SUM_FUNC)
{
mcsv1sdk::mcsv1Context& context = ac->getUDAFContext();
if (context.getRunFlag(UDAF_ORDER_REQUIRED))
{
gwi.parseErrorText =
logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_UDANF_NOT_ALLOWED,
context.getName());
return nullOnError(gwi);
}
}
}
// window frame
WF_Frame frm;
if (win_spec->window_frame)
{
// It is an error to have a frame clause if a UDAnF says it shouldn't
if (item_sum->sum_func() == Item_sum::UDF_SUM_FUNC)
{
mcsv1sdk::mcsv1Context& context = ac->getUDAFContext();
if (!context.getRunFlag(UDAF_WINDOWFRAME_ALLOWED))
{
gwi.parseErrorText =
logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_UDANF_FRAME_NOT_ALLOWED,
context.getName());
return nullOnError(gwi);
}
}
frm.fIsRange = win_spec->window_frame->units == Window_frame::UNITS_RANGE;
// start
if (win_spec->window_frame->top_bound)
{
frm.fStart.fFrame = frame(win_spec->window_frame->top_bound->precedence_type,
win_spec->window_frame->top_bound->offset); // offset NULL means UNBOUNDED
if (win_spec->window_frame->top_bound->offset)
{
frm.fStart.fVal.reset(buildReturnedColumn(win_spec->window_frame->top_bound->offset, gwi, nonSupport));
if (!frm.fStart.fVal)
return nullOnError(gwi);
// 1. check expr is numeric type (rows) or interval (range)
bool boundTypeErr = false;
switch (frm.fStart.fVal->resultType().colDataType)
{
case CalpontSystemCatalog::CHAR:
case CalpontSystemCatalog::VARCHAR:
case CalpontSystemCatalog::VARBINARY:
case CalpontSystemCatalog::BLOB:
case CalpontSystemCatalog::TEXT:
case CalpontSystemCatalog::CLOB:
boundTypeErr = true;
break;
case CalpontSystemCatalog::DATE:
case CalpontSystemCatalog::DATETIME:
case CalpontSystemCatalog::TIME:
case CalpontSystemCatalog::TIMESTAMP:
if (!frm.fIsRange)
boundTypeErr = true;
else if (dynamic_cast<IntervalColumn*>(frm.fStart.fVal.get()) == NULL)
boundTypeErr = true;
break;
default: //okay
break;
}
if (boundTypeErr)
{
gwi.fatalParseError = true;
gwi.parseErrorText =
logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_INVALID_BOUND_TYPE,
colDataTypeToString(frm.fStart.fVal->resultType().colDataType));
return nullOnError(gwi);
}
}
}
// end
if (win_spec->window_frame->bottom_bound)
{
frm.fEnd.fFrame = frame(win_spec->window_frame->bottom_bound->precedence_type,
win_spec->window_frame->bottom_bound->offset);
if (win_spec->window_frame->bottom_bound->offset)
{
frm.fEnd.fVal.reset(buildReturnedColumn(win_spec->window_frame->bottom_bound->offset, gwi, nonSupport));
if (!frm.fEnd.fVal)
return nullOnError(gwi);
// check expr is numeric type (rows) or interval (range)
bool boundTypeErr = false;
switch (frm.fEnd.fVal->resultType().colDataType)
{
case CalpontSystemCatalog::CHAR:
case CalpontSystemCatalog::VARCHAR:
case CalpontSystemCatalog::VARBINARY:
case CalpontSystemCatalog::BLOB:
case CalpontSystemCatalog::TEXT:
case CalpontSystemCatalog::CLOB:
boundTypeErr = true;
break;
case CalpontSystemCatalog::DATE:
case CalpontSystemCatalog::DATETIME:
case CalpontSystemCatalog::TIME:
case CalpontSystemCatalog::TIMESTAMP:
if (!frm.fIsRange)
boundTypeErr = true;
else if (dynamic_cast<IntervalColumn*>(frm.fEnd.fVal.get()) == NULL)
boundTypeErr = true;
break;
default: //okay
break;
}
if (boundTypeErr)
{
gwi.fatalParseError = true;
gwi.parseErrorText =
logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_INVALID_BOUND_TYPE,
colDataTypeToString(frm.fStart.fVal->resultType().colDataType));
return nullOnError(gwi);
}
}
}
else // no end specified. default end to current row
{
frm.fEnd.fFrame = WF_CURRENT_ROW;
}
if (frm.fStart.fVal || frm.fEnd.fVal)
{
// check order by key only 1 (should be error-ed out in parser. double check here)
if (frm.fIsRange && orderBy.fOrders.size() > 1)
{
gwi.fatalParseError = true;
gwi.parseErrorText =
logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_INVALID_ORDER_KEY);
return nullOnError(gwi);
}
// check order by key type is numeric or date/datetime
bool orderTypeErr = false;
if (frm.fIsRange && orderBy.fOrders.size() == 1)
{
switch (orderBy.fOrders[0]->resultType().colDataType)
{
case CalpontSystemCatalog::CHAR:
case CalpontSystemCatalog::VARCHAR:
case CalpontSystemCatalog::VARBINARY:
case CalpontSystemCatalog::BLOB:
case CalpontSystemCatalog::TEXT:
case CalpontSystemCatalog::CLOB:
orderTypeErr = true;
break;
default: //okay
// interval bound has to have date/datetime order key
if ((dynamic_cast<IntervalColumn*>(frm.fStart.fVal.get()) != NULL ||
dynamic_cast<IntervalColumn*>(frm.fEnd.fVal.get()) != NULL))
{
if (orderBy.fOrders[0]->resultType().colDataType != CalpontSystemCatalog::DATE &&
orderBy.fOrders[0]->resultType().colDataType != CalpontSystemCatalog::DATETIME)
orderTypeErr = true;
}
else
{
if (orderBy.fOrders[0]->resultType().colDataType == CalpontSystemCatalog::DATETIME)
orderTypeErr = true;
}
break;
}
if (orderTypeErr)
{
gwi.fatalParseError = true;
gwi.parseErrorText =
logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_INVALID_ORDER_TYPE,
colDataTypeToString(orderBy.fOrders[0]->resultType().colDataType));
return nullOnError(gwi);
}
}
}
// construct +,- or interval function for boundary
if (frm.fIsRange && frm.fStart.fVal)
{
frm.fStart.fBound.reset(buildBoundExp(frm.fStart, orderBy.fOrders[0], gwi));
if (!frm.fStart.fBound)
return nullOnError(gwi);
}
if (frm.fIsRange && frm.fEnd.fVal)
{
frm.fEnd.fBound.reset(buildBoundExp(frm.fEnd, orderBy.fOrders[0], gwi));
if (!frm.fEnd.fVal)
return nullOnError(gwi);
}
}
else
{
// Certain function types have different default boundaries
// This case is kept in enum order in hopes the compiler can optimize
switch (item_sum->sum_func())
{
case Item_sum::COUNT_FUNC:
case Item_sum::COUNT_DISTINCT_FUNC:
case Item_sum::SUM_FUNC:
case Item_sum::SUM_DISTINCT_FUNC:
case Item_sum::AVG_FUNC:
case Item_sum::AVG_DISTINCT_FUNC:
frm.fStart.fFrame = WF_UNBOUNDED_PRECEDING;
frm.fEnd.fFrame = WF_CURRENT_ROW;
break;
case Item_sum::MIN_FUNC:
case Item_sum::MAX_FUNC:
frm.fStart.fFrame = WF_UNBOUNDED_PRECEDING;
// frm.fEnd.fFrame = WF_UNBOUNDED_FOLLOWING;
frm.fEnd.fFrame = WF_CURRENT_ROW;
break;
case Item_sum::STD_FUNC:
case Item_sum::VARIANCE_FUNC:
case Item_sum::SUM_BIT_FUNC:
frm.fStart.fFrame = WF_UNBOUNDED_PRECEDING;
frm.fEnd.fFrame = WF_CURRENT_ROW;
break;
case Item_sum::UDF_SUM_FUNC:
{
// UDAnF functions each have their own default set in context.
mcsv1sdk::mcsv1Context& context = ac->getUDAFContext();
if (context.getRunFlag(UDAF_WINDOWFRAME_REQUIRED))
{
gwi.parseErrorText =
logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_UDANF_FRAME_REQUIRED,
context.getName());
return nullOnError(gwi);
}
int32_t bound;
context.getStartFrame(frm.fStart.fFrame, bound);
if (frm.fStart.fFrame == execplan::WF_PRECEDING)
{
if (bound == 0)
bound = 1;
srcp.reset(new ConstantColumn((int64_t)bound));
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
frm.fStart.fVal = srcp;
frm.fStart.fBound.reset(buildBoundExp(frm.fStart, srcp, gwi));
if (!frm.fStart.fBound)
return nullOnError(gwi);
}
context.getEndFrame(frm.fEnd.fFrame, bound);
if (frm.fEnd.fFrame == execplan::WF_FOLLOWING)
{
if (bound == 0)
bound = 1;
srcp.reset(new ConstantColumn((int64_t)bound));
(dynamic_cast<ConstantColumn*>(srcp.get()))->timeZone(gwi.thd->variables.time_zone->get_name()->ptr());
frm.fEnd.fVal = srcp;
frm.fEnd.fBound.reset(buildBoundExp(frm.fEnd, srcp, gwi));
if (!frm.fEnd.fBound)
return nullOnError(gwi);
}
break;
}
case Item_sum::GROUP_CONCAT_FUNC:
frm.fStart.fFrame = WF_UNBOUNDED_PRECEDING;
frm.fEnd.fFrame = WF_CURRENT_ROW;
break;
case Item_sum::ROW_NUMBER_FUNC:
case Item_sum::RANK_FUNC:
case Item_sum::DENSE_RANK_FUNC:
case Item_sum::PERCENT_RANK_FUNC:
case Item_sum::CUME_DIST_FUNC:
case Item_sum::NTILE_FUNC:
frm.fStart.fFrame = WF_UNBOUNDED_PRECEDING;
frm.fEnd.fFrame = WF_UNBOUNDED_FOLLOWING;
break;
case Item_sum::FIRST_VALUE_FUNC:
case Item_sum::LAST_VALUE_FUNC:
case Item_sum::NTH_VALUE_FUNC:
frm.fStart.fFrame = WF_UNBOUNDED_PRECEDING;
frm.fEnd.fFrame = WF_CURRENT_ROW;
break;
case Item_sum::LEAD_FUNC:
case Item_sum::LAG_FUNC:
frm.fStart.fFrame = WF_UNBOUNDED_PRECEDING;
frm.fEnd.fFrame = WF_UNBOUNDED_FOLLOWING;
break;
default:
frm.fStart.fFrame = WF_UNBOUNDED_PRECEDING;
frm.fEnd.fFrame = WF_CURRENT_ROW;
break;
};
}
orderBy.fFrame = frm;
ac->orderBy(orderBy);
}
if (gwi.fatalParseError || nonSupport)
{
if (gwi.parseErrorText.empty())
gwi.parseErrorText = logging::IDBErrorInfo::instance()->errorMsg(logging::ERR_WF_NON_SUPPORT);
setError(gwi.thd, ER_CHECK_NOT_IMPLEMENTED, gwi.parseErrorText);
return NULL;
}
#if 0
if (item_sum->sum_func() != Item_sum::UDF_SUM_FUNC &&
item_sum->sum_func() != Item_sum::SUM_FUNC &&
item_sum->sum_func() != Item_sum::SUM_DISTINCT_FUNC &&
item_sum->sum_func() != Item_sum::AVG_FUNC &&
item_sum->sum_func() != Item_sum::AVG_DISTINCT_FUNC)
#endif
if (item_sum->sum_func() != Item_sum::UDF_SUM_FUNC)
{
ac->resultType(colType_MysqlToIDB(item_sum));
// bug5736. Make the result type double for some window functions when
// plugin variable double_for_decimal_math is set.
ac->adjustResultType();
}
ac->expressionId(ci->expressionId++);
if (item->full_name())
ac->alias(item->full_name());
ac->charsetNumber(item->collation.collation->number);
// put ac on windowFuncList
gwi.windowFuncList.push_back(ac);
return ac;
}
}
View Git Blame Copy Permalink