Skip to content

G
Gpdb

Greenplum / Gpdb

通知 7
Star 1
Fork 0
G
Gpdb

体验新版 GitCode，发现更多精彩内容 >>

提交 aad4e7fa 编写于 作者: B Bhuvnesh Chaudhary 提交者： Omer Arap
浏览文件
操作

Adding scalar ArrayCoerceExpr support in GPORCA [#117186547] 

Signed-off-by: NEkta Khanna <ekhanna@pivotal.io>
Signed-off-by: NXin Zhang <xzhang@pivotal.io>
上级 78b6ccd5
隐藏空白更改
内联 并排
Showing with 1255 addition and 1 deletion
data/dxl/minidump/ArrayCoerceExpr.mdp 0 → 100644
浏览文件 @ aad4e7fa
<?xml version="1.0" encoding="UTF-8"?>
<dxl:DXLMessage xmlns:dxl="http://greenplum.com/dxl/2010/12/">
<dxl:Thread Id="0">
<dxl:OptimizerConfig>
<dxl:EnumeratorConfig Id="0" PlanSamples="0" CostThreshold="0"/>
<dxl:StatisticsConfig DampingFactorFilter="0.750000" DampingFactorJoin="0.010000" DampingFactorGroupBy="0.750000"/>
<dxl:CTEConfig CTEInliningCutoff="0"/>
<dxl:CostModelConfig CostModelType="1" SegmentsForCosting="3"/>
<dxl:Hint MinNumOfPartsToRequireSortOnInsert="2147483647" JoinArityForAssociativityCommutativity="2147483647" ArrayExpansionThreshold="25" JoinOrderDynamicProgThreshold="10" BroadcastThreshold="10000000"/>
<dxl:TraceFlags Value="102120,103001,103014,103015,103022,104004,104005,105000"/>
</dxl:OptimizerConfig>
<dxl:Metadata SystemIds="0.GPDB">
<dxl:RelationStatistics Mdid="2.97283.1.1" Name="foo" Rows="0.000000" EmptyRelation="true"/>
<dxl:Relation Mdid="0.97283.1.1" Name="foo" IsTemporary="false" HasOids="false" StorageType="Heap" DistributionPolicy="Hash" DistributionColumns="0" Keys="8,2" NumberLeafPartitions="0">
<dxl:Columns>
<dxl:Column Name="c" Attno="1" Mdid="0.23.1.0" Nullable="true">
<dxl:DefaultValue/>
</dxl:Column>
<dxl:Column Name="d" Attno="2" Mdid="0.1043.1.0" Nullable="true" ColWidth="10">
<dxl:DefaultValue/>
</dxl:Column>
<dxl:Column Name="ctid" Attno="-1" Mdid="0.27.1.0" Nullable="false">
<dxl:DefaultValue/>
</dxl:Column>
<dxl:Column Name="xmin" Attno="-3" Mdid="0.28.1.0" Nullable="false">
<dxl:DefaultValue/>
</dxl:Column>
<dxl:Column Name="cmin" Attno="-4" Mdid="0.29.1.0" Nullable="false">
<dxl:DefaultValue/>
</dxl:Column>
<dxl:Column Name="xmax" Attno="-5" Mdid="0.28.1.0" Nullable="false">
<dxl:DefaultValue/>
</dxl:Column>
<dxl:Column Name="cmax" Attno="-6" Mdid="0.29.1.0" Nullable="false">
<dxl:DefaultValue/>
</dxl:Column>
<dxl:Column Name="tableoid" Attno="-7" Mdid="0.26.1.0" Nullable="false">
<dxl:DefaultValue/>
</dxl:Column>
<dxl:Column Name="gp_segment_id" Attno="-8" Mdid="0.23.1.0" Nullable="false">
<dxl:DefaultValue/>
</dxl:Column>
</dxl:Columns>
<dxl:Indexes/>
<dxl:Triggers/>
<dxl:CheckConstraints/>
</dxl:Relation>
<dxl:ColumnStatistics Mdid="1.97283.1.1.8" Name="gp_segment_id" Width="4.000000" NullFreq="0.000000" NdvRemain="0.000000" FreqRemain="0.000000" ColStatsMissing="true"/>
<dxl:ColumnStatistics Mdid="1.97283.1.1.1" Name="d" Width="8.000000" NullFreq="0.000000" NdvRemain="0.000000" FreqRemain="0.000000" ColStatsMissing="true"/>
<dxl:ColumnStatistics Mdid="1.97283.1.1.0" Name="c" Width="4.000000" NullFreq="0.000000" NdvRemain="0.000000" FreqRemain="0.000000" ColStatsMissing="true"/>
<dxl:Type Mdid="0.16.1.0" Name="bool" IsRedistributable="true" IsHashable="true" IsComposite="false" IsFixedLength="true" Length="1" PassByValue="true">
<dxl:EqualityOp Mdid="0.91.1.0"/>
<dxl:InequalityOp Mdid="0.85.1.0"/>
<dxl:LessThanOp Mdid="0.58.1.0"/>
<dxl:LessThanEqualsOp Mdid="0.1694.1.0"/>
<dxl:GreaterThanOp Mdid="0.59.1.0"/>
<dxl:GreaterThanEqualsOp Mdid="0.1695.1.0"/>
<dxl:ComparisonOp Mdid="0.1693.1.0"/>
<dxl:ArrayType Mdid="0.1000.1.0"/>
<dxl:MinAgg Mdid="0.0.0.0"/>
<dxl:MaxAgg Mdid="0.0.0.0"/>
<dxl:AvgAgg Mdid="0.0.0.0"/>
<dxl:SumAgg Mdid="0.0.0.0"/>
<dxl:CountAgg Mdid="0.2147.1.0"/>
</dxl:Type>
<dxl:Type Mdid="0.1043.1.0" Name="varchar" IsRedistributable="true" IsHashable="true" IsComposite="false" IsFixedLength="false" PassByValue="false">
<dxl:EqualityOp Mdid="0.98.1.0"/>
<dxl:InequalityOp Mdid="0.531.1.0"/>
<dxl:LessThanOp Mdid="0.664.1.0"/>
<dxl:LessThanEqualsOp Mdid="0.665.1.0"/>
<dxl:GreaterThanOp Mdid="0.666.1.0"/>
<dxl:GreaterThanEqualsOp Mdid="0.667.1.0"/>
<dxl:ComparisonOp Mdid="0.360.1.0"/>
<dxl:ArrayType Mdid="0.1015.1.0"/>
<dxl:MinAgg Mdid="0.0.0.0"/>
<dxl:MaxAgg Mdid="0.0.0.0"/>
<dxl:AvgAgg Mdid="0.0.0.0"/>
<dxl:SumAgg Mdid="0.0.0.0"/>
<dxl:CountAgg Mdid="0.2147.1.0"/>
</dxl:Type>
<dxl:Type Mdid="0.23.1.0" Name="int4" IsRedistributable="true" IsHashable="true" IsComposite="false" IsFixedLength="true" Length="4" PassByValue="true">
<dxl:EqualityOp Mdid="0.96.1.0"/>
<dxl:InequalityOp Mdid="0.518.1.0"/>
<dxl:LessThanOp Mdid="0.97.1.0"/>
<dxl:LessThanEqualsOp Mdid="0.523.1.0"/>
<dxl:GreaterThanOp Mdid="0.521.1.0"/>
<dxl:GreaterThanEqualsOp Mdid="0.525.1.0"/>
<dxl:ComparisonOp Mdid="0.351.1.0"/>
<dxl:ArrayType Mdid="0.1007.1.0"/>
<dxl:MinAgg Mdid="0.2132.1.0"/>
<dxl:MaxAgg Mdid="0.2116.1.0"/>
<dxl:AvgAgg Mdid="0.2101.1.0"/>
<dxl:SumAgg Mdid="0.2108.1.0"/>
<dxl:CountAgg Mdid="0.2147.1.0"/>
</dxl:Type>
<dxl:Type Mdid="0.26.1.0" Name="oid" IsRedistributable="true" IsHashable="true" IsComposite="false" IsFixedLength="true" Length="4" PassByValue="true">
<dxl:EqualityOp Mdid="0.607.1.0"/>
<dxl:InequalityOp Mdid="0.608.1.0"/>
<dxl:LessThanOp Mdid="0.609.1.0"/>
<dxl:LessThanEqualsOp Mdid="0.611.1.0"/>
<dxl:GreaterThanOp Mdid="0.610.1.0"/>
<dxl:GreaterThanEqualsOp Mdid="0.612.1.0"/>
<dxl:ComparisonOp Mdid="0.356.1.0"/>
<dxl:ArrayType Mdid="0.1028.1.0"/>
<dxl:MinAgg Mdid="0.2118.1.0"/>
<dxl:MaxAgg Mdid="0.2134.1.0"/>
<dxl:AvgAgg Mdid="0.0.0.0"/>
<dxl:SumAgg Mdid="0.0.0.0"/>
<dxl:CountAgg Mdid="0.2147.1.0"/>
</dxl:Type>
<dxl:Type Mdid="0.27.1.0" Name="tid" IsRedistributable="true" IsHashable="false" IsComposite="false" IsFixedLength="true" Length="6" PassByValue="false">
<dxl:EqualityOp Mdid="0.387.1.0"/>
<dxl:InequalityOp Mdid="0.402.1.0"/>
<dxl:LessThanOp Mdid="0.2799.1.0"/>
<dxl:LessThanEqualsOp Mdid="0.2801.1.0"/>
<dxl:GreaterThanOp Mdid="0.2800.1.0"/>
<dxl:GreaterThanEqualsOp Mdid="0.2802.1.0"/>
<dxl:ComparisonOp Mdid="0.2794.1.0"/>
<dxl:ArrayType Mdid="0.1010.1.0"/>
<dxl:MinAgg Mdid="0.2798.1.0"/>
<dxl:MaxAgg Mdid="0.2797.1.0"/>
<dxl:AvgAgg Mdid="0.0.0.0"/>
<dxl:SumAgg Mdid="0.0.0.0"/>
<dxl:CountAgg Mdid="0.2147.1.0"/>
</dxl:Type>
<dxl:Type Mdid="0.29.1.0" Name="cid" IsRedistributable="false" IsHashable="true" IsComposite="false" IsFixedLength="true" Length="4" PassByValue="true">
<dxl:EqualityOp Mdid="0.385.1.0"/>
<dxl:InequalityOp Mdid="0.0.0.0"/>
<dxl:LessThanOp Mdid="0.0.0.0"/>
<dxl:LessThanEqualsOp Mdid="0.0.0.0"/>
<dxl:GreaterThanOp Mdid="0.0.0.0"/>
<dxl:GreaterThanEqualsOp Mdid="0.0.0.0"/>
<dxl:ComparisonOp Mdid="0.0.0.0"/>
<dxl:ArrayType Mdid="0.1012.1.0"/>
<dxl:MinAgg Mdid="0.0.0.0"/>
<dxl:MaxAgg Mdid="0.0.0.0"/>
<dxl:AvgAgg Mdid="0.0.0.0"/>
<dxl:SumAgg Mdid="0.0.0.0"/>
<dxl:CountAgg Mdid="0.2147.1.0"/>
</dxl:Type>
<dxl:Type Mdid="0.28.1.0" Name="xid" IsRedistributable="false" IsHashable="true" IsComposite="false" IsFixedLength="true" Length="4" PassByValue="true">
<dxl:EqualityOp Mdid="0.352.1.0"/>
<dxl:InequalityOp Mdid="0.0.0.0"/>
<dxl:LessThanOp Mdid="0.0.0.0"/>
<dxl:LessThanEqualsOp Mdid="0.0.0.0"/>
<dxl:GreaterThanOp Mdid="0.0.0.0"/>
<dxl:GreaterThanEqualsOp Mdid="0.0.0.0"/>
<dxl:ComparisonOp Mdid="0.0.0.0"/>
<dxl:ArrayType Mdid="0.1011.1.0"/>
<dxl:MinAgg Mdid="0.0.0.0"/>
<dxl:MaxAgg Mdid="0.0.0.0"/>
<dxl:AvgAgg Mdid="0.0.0.0"/>
<dxl:SumAgg Mdid="0.0.0.0"/>
<dxl:CountAgg Mdid="0.2147.1.0"/>
</dxl:Type>
<dxl:ColumnStatistics Mdid="1.97283.1.1.3" Name="xmin" Width="4.000000" NullFreq="0.000000" NdvRemain="0.000000" FreqRemain="0.000000" ColStatsMissing="true"/>
<dxl:ColumnStatistics Mdid="1.97283.1.1.2" Name="ctid" Width="6.000000" NullFreq="0.000000" NdvRemain="0.000000" FreqRemain="0.000000" ColStatsMissing="true"/>
<dxl:MDCast Mdid="3.1043.1.0;25.1.0" Name="text" BinaryCoercible="true" SourceTypeId="0.1043.1.0" DestinationTypeId="0.25.1.0" CastFuncId="0.0.0.0"/>
<dxl:ColumnStatistics Mdid="1.97283.1.1.5" Name="xmax" Width="4.000000" NullFreq="0.000000" NdvRemain="0.000000" FreqRemain="0.000000" ColStatsMissing="true"/>
<dxl:ColumnStatistics Mdid="1.97283.1.1.4" Name="cmin" Width="4.000000" NullFreq="0.000000" NdvRemain="0.000000" FreqRemain="0.000000" ColStatsMissing="true"/>
<dxl:GPDBScalarOp Mdid="0.98.1.0" Name="=" ComparisonType="Eq" ReturnsNullOnNullInput="true">
<dxl:LeftType Mdid="0.25.1.0"/>
<dxl:RightType Mdid="0.25.1.0"/>
<dxl:ResultType Mdid="0.16.1.0"/>
<dxl:OpFunc Mdid="0.67.1.0"/>
<dxl:Commutator Mdid="0.98.1.0"/>
<dxl:InverseOp Mdid="0.531.1.0"/>
<dxl:OpClasses>
<dxl:OpClass Mdid="0.1994.1.0"/>
<dxl:OpClass Mdid="0.1995.1.0"/>
<dxl:OpClass Mdid="0.3035.1.0"/>
</dxl:OpClasses>
</dxl:GPDBScalarOp>
<dxl:ColumnStatistics Mdid="1.97283.1.1.7" Name="tableoid" Width="4.000000" NullFreq="0.000000" NdvRemain="0.000000" FreqRemain="0.000000" ColStatsMissing="true"/>
<dxl:ColumnStatistics Mdid="1.97283.1.1.6" Name="cmax" Width="4.000000" NullFreq="0.000000" NdvRemain="0.000000" FreqRemain="0.000000" ColStatsMissing="true"/>
</dxl:Metadata>
<dxl:Query>
<dxl:OutputColumns>
<dxl:Ident ColId="1" ColName="c" TypeMdid="0.23.1.0"/>
<dxl:Ident ColId="2" ColName="d" TypeMdid="0.1043.1.0"/>
</dxl:OutputColumns>
<dxl:CTEList/>
<dxl:LogicalSelect>
<dxl:ArrayComp OperatorName="=" OperatorMdid="0.98.1.0" OperatorType="Any">
<dxl:Cast TypeMdid="0.25.1.0" FuncId="0.0.0.0">
<dxl:Ident ColId="2" ColName="d" TypeMdid="0.1043.1.0"/>
</dxl:Cast>
<dxl:ArrayCoerceExpr ElementFunc="0.0.0.0" TypeMdid="0.1009.1.0" TypeModification="-1" IsExplicit="false" CoercionForm="2" Location="0">
<dxl:Array ArrayType="0.1015.1.0" ElementType="0.1043.1.0" MultiDimensional="false">
<dxl:ConstValue TypeMdid="0.1043.1.0" IsNull="false" IsByValue="false" Value="AAAABWE=" LintValue="160440876"/>
<dxl:ConstValue TypeMdid="0.1043.1.0" IsNull="false" IsByValue="false" Value="AAAABWI=" LintValue="160449068"/>
</dxl:Array>
</dxl:ArrayCoerceExpr>
</dxl:ArrayComp>
<dxl:LogicalGet>
<dxl:TableDescriptor Mdid="0.97283.1.1" TableName="foo">
<dxl:Columns>
<dxl:Column ColId="1" Attno="1" ColName="c" TypeMdid="0.23.1.0"/>
<dxl:Column ColId="2" Attno="2" ColName="d" TypeMdid="0.1043.1.0" ColWidth="10"/>
<dxl:Column ColId="3" Attno="-1" ColName="ctid" TypeMdid="0.27.1.0"/>
<dxl:Column ColId="4" Attno="-3" ColName="xmin" TypeMdid="0.28.1.0"/>
<dxl:Column ColId="5" Attno="-4" ColName="cmin" TypeMdid="0.29.1.0"/>
<dxl:Column ColId="6" Attno="-5" ColName="xmax" TypeMdid="0.28.1.0"/>
<dxl:Column ColId="7" Attno="-6" ColName="cmax" TypeMdid="0.29.1.0"/>
<dxl:Column ColId="8" Attno="-7" ColName="tableoid" TypeMdid="0.26.1.0"/>
<dxl:Column ColId="9" Attno="-8" ColName="gp_segment_id" TypeMdid="0.23.1.0"/>
</dxl:Columns>
</dxl:TableDescriptor>
</dxl:LogicalGet>
</dxl:LogicalSelect>
</dxl:Query>
<dxl:Plan Id="0" SpaceSize="1">
<dxl:GatherMotion InputSegments="0,1,2" OutputSegments="-1">
<dxl:Properties>
<dxl:Cost StartupCost="0" TotalCost="431.000071" Rows="1.000000" Width="12"/>
</dxl:Properties>
<dxl:ProjList>
<dxl:ProjElem ColId="0" Alias="c">
<dxl:Ident ColId="0" ColName="c" TypeMdid="0.23.1.0"/>
</dxl:ProjElem>
<dxl:ProjElem ColId="1" Alias="d">
<dxl:Ident ColId="1" ColName="d" TypeMdid="0.1043.1.0"/>
</dxl:ProjElem>
</dxl:ProjList>
<dxl:Filter/>
<dxl:SortingColumnList/>
<dxl:TableScan>
<dxl:Properties>
<dxl:Cost StartupCost="0" TotalCost="431.000026" Rows="1.000000" Width="12"/>
</dxl:Properties>
<dxl:ProjList>
<dxl:ProjElem ColId="0" Alias="c">
<dxl:Ident ColId="0" ColName="c" TypeMdid="0.23.1.0"/>
</dxl:ProjElem>
<dxl:ProjElem ColId="1" Alias="d">
<dxl:Ident ColId="1" ColName="d" TypeMdid="0.1043.1.0"/>
</dxl:ProjElem>
</dxl:ProjList>
<dxl:Filter>
<dxl:ArrayComp OperatorName="=" OperatorMdid="0.98.1.0" OperatorType="Any">
<dxl:Cast TypeMdid="0.25.1.0" FuncId="0.0.0.0">
<dxl:Ident ColId="1" ColName="d" TypeMdid="0.1043.1.0"/>
</dxl:Cast>
<dxl:ArrayCoerceExpr ElementFunc="0.0.0.0" TypeMdid="0.1009.1.0" TypeModification="-1" IsExplicit="false" CoercionForm="2" Location="0">
<dxl:Array ArrayType="0.1015.1.0" ElementType="0.1043.1.0" MultiDimensional="false">
<dxl:ConstValue TypeMdid="0.1043.1.0" IsNull="false" IsByValue="false" Value="AAAABWE=" LintValue="160440876"/>
<dxl:ConstValue TypeMdid="0.1043.1.0" IsNull="false" IsByValue="false" Value="AAAABWI=" LintValue="160449068"/>
</dxl:Array>
</dxl:ArrayCoerceExpr>
</dxl:ArrayComp>
</dxl:Filter>
<dxl:TableDescriptor Mdid="0.97283.1.1" TableName="foo">
<dxl:Columns>
<dxl:Column ColId="0" Attno="1" ColName="c" TypeMdid="0.23.1.0"/>
<dxl:Column ColId="1" Attno="2" ColName="d" TypeMdid="0.1043.1.0" ColWidth="10"/>
<dxl:Column ColId="2" Attno="-1" ColName="ctid" TypeMdid="0.27.1.0"/>
<dxl:Column ColId="3" Attno="-3" ColName="xmin" TypeMdid="0.28.1.0"/>
<dxl:Column ColId="4" Attno="-4" ColName="cmin" TypeMdid="0.29.1.0"/>
<dxl:Column ColId="5" Attno="-5" ColName="xmax" TypeMdid="0.28.1.0"/>
<dxl:Column ColId="6" Attno="-6" ColName="cmax" TypeMdid="0.29.1.0"/>
<dxl:Column ColId="7" Attno="-7" ColName="tableoid" TypeMdid="0.26.1.0"/>
<dxl:Column ColId="8" Attno="-8" ColName="gp_segment_id" TypeMdid="0.23.1.0"/>
</dxl:Columns>
</dxl:TableDescriptor>
</dxl:TableScan>
</dxl:GatherMotion>
</dxl:Plan>
</dxl:Thread>
</dxl:DXLMessage>
libgpopt/CMakeLists.txt
浏览文件 @ aad4e7fa
......@@ -547,6 +547,8 @@ add_library(gpopt
src/operators/CScalarCoerceToDomain.cpp
include/gpopt/operators/CScalarCoerceViaIO.h
src/operators/CScalarCoerceViaIO.cpp
include/gpopt/operators/CScalarArrayCoerceExpr.h
src/operators/CScalarArrayCoerceExpr.cpp
include/gpopt/operators/CScalarConst.h
src/operators/CScalarConst.cpp
include/gpopt/operators/CScalarDMLAction.h
......
libgpopt/include/gpopt/operators/COperator.h
浏览文件 @ aad4e7fa
......@@ -185,6 +185,7 @@ namespace gpopt
EopScalarCast,
EopScalarCoerceToDomain,
EopScalarCoerceViaIO,
EopScalarArrayCoerceExpr,
EopScalarCoalesce,
EopScalarArray,
EopScalarArrayCmp,
......
libgpopt/include/gpopt/operators/CScalarArrayCoerceExpr.h 0 → 100644
浏览文件 @ aad4e7fa
//---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2017 Pivotal Inc.
//
// @filename:
// CScalarArrayCoerceExpr.h
//
// @doc:
// Scalar Array Coerce Expr operator,
// the operator will apply type casting for each element in this array
// using the given element coercion function.
//
// @owner:
//
// @test:
//
//
//---------------------------------------------------------------------------
#ifndef GPOPT_CScalarArrayCoerceExpr_H
#define GPOPT_CScalarArrayCoerceExpr_H
#include "gpos/base.h"
#include "gpopt/base/COptCtxt.h"
#include "gpopt/operators/CScalar.h"
#include "gpopt/base/CDrvdProp.h"
namespace gpopt
{
using namespace gpos;
//---------------------------------------------------------------------------
// @class:
// CScalarArrayCoerceExpr
//
// @doc:
// Scalar Array Coerce Expr operator
//
//---------------------------------------------------------------------------
class CScalarArrayCoerceExpr : public CScalar
{
private:
// catalog MDId of the element function
IMDId *m_pmdidElementFunc;
// catalog MDId of the result type
IMDId *m_pmdidResultType;
// output type modifications
INT m_iMod;
// conversion semantics flag to pass to func
BOOL m_fIsExplicit;
// coercion form
ECoercionForm m_ecf;
// location of token to be coerced
INT m_iLoc;
// private copy ctor
CScalarArrayCoerceExpr(const CScalarArrayCoerceExpr &);
public:
// ctor
CScalarArrayCoerceExpr
(
IMemoryPool *pmp,
IMDId *pmdidElementFunc,
IMDId *pmdidResultType,
INT iMod,
BOOL fIsExplicit,
ECoercionForm edxlcf,
INT iLoc
);
// dtor
virtual
~CScalarArrayCoerceExpr()
{
m_pmdidElementFunc->Release();
m_pmdidResultType->Release();
}
// return metadata id of element coerce function
IMDId *PmdidElementFunc() const
{
return m_pmdidElementFunc;
}
// the type of the scalar expression
virtual
IMDId *PmdidType() const
{
return m_pmdidResultType;
}
// return type modification
INT IMod() const
{
return m_iMod;
}
BOOL FIsExplicit() const
{
return m_fIsExplicit;
}
// return coercion form
ECoercionForm Ecf() const
{
return m_ecf;
}
// return token location
INT ILoc() const
{
return m_iLoc;
}
virtual
EOperatorId Eopid() const
{
return EopScalarArrayCoerceExpr;
}
// return a string for operator name
virtual
const CHAR *SzId() const
{
return "CScalarArrayCoerceExpr";
}
// match function
virtual
BOOL FMatch(COperator *) const;
// sensitivity to order of inputs
virtual
BOOL FInputOrderSensitive() const
{
return false;
}
// return a copy of the operator with remapped columns
virtual
COperator *PopCopyWithRemappedColumns
(
IMemoryPool *, //pmp,
HMUlCr *, //phmulcr,
BOOL //fMustExist
)
{
return PopCopyDefault();
}
// conversion function
static
CScalarArrayCoerceExpr *PopConvert
(
COperator *pop
)
{
GPOS_ASSERT(NULL != pop);
GPOS_ASSERT(EopScalarArrayCoerceExpr == pop->Eopid());
return dynamic_cast<CScalarArrayCoerceExpr*>(pop);
}
}; // class CScalarArrayCoerceExpr
}
#endif // !GPOPT_CScalarArrayCoerceExpr_H
// EOF
libgpopt/include/gpopt/operators/ops.h
浏览文件 @ aad4e7fa
......@@ -37,6 +37,7 @@
#include "gpopt/operators/CScalarCast.h"
#include "gpopt/operators/CScalarCoerceToDomain.h"
#include "gpopt/operators/CScalarCoerceViaIO.h"
#include "gpopt/operators/CScalarArrayCoerceExpr.h"
#include "gpopt/operators/CScalarCoalesce.h"
#include "gpopt/operators/CScalarMinMax.h"
#include "gpopt/operators/CScalarSubquery.h"
......
libgpopt/include/gpopt/translate/CTranslatorDXLToExpr.h
浏览文件 @ aad4e7fa
......@@ -332,6 +332,9 @@ namespace gpopt
// translate a DXL scalar coerce a scalar coerce using I/O functions
CExpression *PexprScalarCoerceViaIO(const CDXLNode *pdxlnCoerce);
// translate a DXL scalar array coerce expression using given element coerce function
CExpression *PexprScalarArrayCoerceExpr(const CDXLNode *pdxlnArrayCoerceExpr);
// translate a DXL scalar subquery operator into a scalar subquery expression
CExpression *PexprScalarSubquery(const CDXLNode *pdxlnSubquery);
......
libgpopt/include/gpopt/translate/CTranslatorExprToDXL.h
浏览文件 @ aad4e7fa
......@@ -597,6 +597,9 @@ namespace gpopt
// translate a scalar coerce using I/O functions
CDXLNode *PdxlnScCoerceViaIO(CExpression *pexprScCoerce);
// translate a scalar array coerce expr with element coerce function
CDXLNode *PdxlnScArrayCoerceExpr(CExpression *pexprScArrayCoerceExpr);
// translate an array
CDXLNode *PdxlnArray(CExpression *pexpr);
......
libgpopt/src/operators/CScalarArrayCoerceExpr.cpp 0 → 100644
浏览文件 @ aad4e7fa
//---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2017 Pivotal Inc.
//
// @filename:
// CScalarArrayCoerceExpr.cpp
//
// @doc:
// Implementation of scalar array coerce expr operator
//
// @owner:
//
// @test:
//
//
//---------------------------------------------------------------------------
#include "gpos/base.h"
#include "gpopt/base/CDrvdPropScalar.h"
#include "gpopt/base/CColRefSet.h"
#include "gpopt/mdcache/CMDAccessorUtils.h"
#include "gpopt/operators/CScalarArrayCoerceExpr.h"
#include "gpopt/operators/CExpressionHandle.h"
#include "naucrates/md/IMDTypeBool.h"
using namespace gpopt;
using namespace gpmd;
//---------------------------------------------------------------------------
// @function:
// CScalarArrayCoerceExpr::CScalarArrayCoerceExpr
//
// @doc:
// Ctor
//
//---------------------------------------------------------------------------
CScalarArrayCoerceExpr::CScalarArrayCoerceExpr
(
IMemoryPool *pmp,
IMDId *pmdidElementFunc,
IMDId *pmdidResultType,
INT iMod,
BOOL fIsExplicit,
ECoercionForm ecf,
INT iLoc
)
:
CScalar(pmp),
m_pmdidElementFunc(pmdidElementFunc),
m_pmdidResultType(pmdidResultType),
m_iMod(iMod),
m_fIsExplicit(fIsExplicit),
m_ecf(ecf),
m_iLoc(iLoc)
{
GPOS_ASSERT(NULL != pmdidElementFunc);
GPOS_ASSERT(NULL != pmdidResultType);
GPOS_ASSERT(pmdidResultType->FValid());
}
//---------------------------------------------------------------------------
// @function:
// CScalarArrayCoerceExpr::FMatch
//
// @doc:
// Match function on operator level
//
//---------------------------------------------------------------------------
BOOL
CScalarArrayCoerceExpr::FMatch
(
COperator *pop
)
const
{
if (pop->Eopid() != Eopid())
{
return false;
}
CScalarArrayCoerceExpr *popCoerce = CScalarArrayCoerceExpr::PopConvert(pop);
return popCoerce->PmdidElementFunc()->FEquals(m_pmdidElementFunc) &&
popCoerce->PmdidType()->FEquals(m_pmdidResultType) &&
popCoerce->IMod() == m_iMod &&
popCoerce->FIsExplicit() == m_fIsExplicit &&
popCoerce->Ecf() == m_ecf &&
popCoerce->ILoc() == m_iLoc;
}
// EOF
libgpopt/src/translate/CTranslatorDXLToExpr.cpp
浏览文件 @ aad4e7fa
......@@ -172,6 +172,7 @@ CTranslatorDXLToExpr::InitTranslators()
{EdxlopScalarSwitchCase, &gpopt::CTranslatorDXLToExpr::PexprScalarSwitchCase},
{EdxlopScalarCaseTest, &gpopt::CTranslatorDXLToExpr::PexprScalarCaseTest},
{EdxlopScalarCoalesce, &gpopt::CTranslatorDXLToExpr::PexprScalarCoalesce},
{EdxlopScalarArrayCoerceExpr, &gpopt::CTranslatorDXLToExpr::PexprScalarArrayCoerceExpr},
{EdxlopScalarCast, &gpopt::CTranslatorDXLToExpr::PexprScalarCast},
{EdxlopScalarCoerceToDomain,&gpopt::CTranslatorDXLToExpr::PexprScalarCoerceToDomain},
{EdxlopScalarCoerceViaIO, &gpopt::CTranslatorDXLToExpr::PexprScalarCoerceViaIO},
......@@ -3665,6 +3666,52 @@ CTranslatorDXLToExpr::PexprScalarCoerceViaIO
);
}
//---------------------------------------------------------------------------
// @function:
// CTranslatorDXLToExpr::PexprScalarArrayCoerceExpr
//
// @doc:
// Create a scalar array coerce expr from a DXL scalar array coerce expr
//
//---------------------------------------------------------------------------
CExpression *
CTranslatorDXLToExpr::PexprScalarArrayCoerceExpr
(
const CDXLNode *pdxlnArrayCoerceExpr
)
{
GPOS_ASSERT(NULL != pdxlnArrayCoerceExpr);
CDXLScalarArrayCoerceExpr *pdxlop = CDXLScalarArrayCoerceExpr::PdxlopConvert(pdxlnArrayCoerceExpr->Pdxlop());
GPOS_ASSERT(1 == pdxlnArrayCoerceExpr->UlArity());
CDXLNode *pdxlnChild = (*pdxlnArrayCoerceExpr)[0];
CExpression *pexprChild = Pexpr(pdxlnChild);
IMDId *pmdidElementFunc = pdxlop->PmdidElementFunc();
pmdidElementFunc->AddRef();
IMDId *pmdidResultType = pdxlop->PmdidResultType();
pmdidResultType->AddRef();
EdxlCoercionForm edxlcf = pdxlop->Edxlcf();
return GPOS_NEW(m_pmp) CExpression
(
m_pmp,
GPOS_NEW(m_pmp) CScalarArrayCoerceExpr
(
m_pmp,
pmdidElementFunc,
pmdidResultType,
pdxlop->IMod(),
pdxlop->FIsExplicit(),
(COperator::ECoercionForm) edxlcf, // map Coercion Form directly based on position in enum
pdxlop->ILoc()
),
pexprChild
);
}
//---------------------------------------------------------------------------
// @function:
......
libgpopt/src/translate/CTranslatorExprToDXL.cpp
浏览文件 @ aad4e7fa
......@@ -155,6 +155,7 @@ CTranslatorExprToDXL::InitScalarTranslators()
{COperator::EopScalarCast, &gpopt::CTranslatorExprToDXL::PdxlnScCast},
{COperator::EopScalarCoerceToDomain, &gpopt::CTranslatorExprToDXL::PdxlnScCoerceToDomain},
{COperator::EopScalarCoerceViaIO, &gpopt::CTranslatorExprToDXL::PdxlnScCoerceViaIO},
{COperator::EopScalarArrayCoerceExpr, &gpopt::CTranslatorExprToDXL::PdxlnScArrayCoerceExpr},
{COperator::EopScalarArray, &gpopt::CTranslatorExprToDXL::PdxlnArray},
{COperator::EopScalarArrayCmp, &gpopt::CTranslatorExprToDXL::PdxlnArrayCmp},
{COperator::EopScalarArrayRef, &gpopt::CTranslatorExprToDXL::PdxlnArrayRef},
......@@ -6430,6 +6431,52 @@ CTranslatorExprToDXL::PdxlnScCoerceViaIO
return pdxlnCoerce;
}
//---------------------------------------------------------------------------
// @function:
// CTranslatorExprToDXL::PdxlnScArrayCoerceExpr
//
// @doc:
// Create a DXL node from an optimizer scalar array coerce expr.
//
//---------------------------------------------------------------------------
CDXLNode *
CTranslatorExprToDXL::PdxlnScArrayCoerceExpr
(
CExpression *pexprArrayCoerceExpr
)
{
GPOS_ASSERT(NULL != pexprArrayCoerceExpr);
CScalarArrayCoerceExpr *popScArrayCoerceExpr = CScalarArrayCoerceExpr::PopConvert(pexprArrayCoerceExpr->Pop());
IMDId *pmdidElemFunc = popScArrayCoerceExpr->PmdidElementFunc();
pmdidElemFunc->AddRef();
IMDId *pmdid = popScArrayCoerceExpr->PmdidType();
pmdid->AddRef();
CDXLNode *pdxlnArrayCoerceExpr =
GPOS_NEW(m_pmp) CDXLNode
(
m_pmp,
GPOS_NEW(m_pmp) CDXLScalarArrayCoerceExpr
(
m_pmp,
pmdidElemFunc,
pmdid,
popScArrayCoerceExpr->IMod(),
popScArrayCoerceExpr->FIsExplicit(),
(EdxlCoercionForm) popScArrayCoerceExpr->Ecf(), // map Coercion Form directly based on position in enum
popScArrayCoerceExpr->ILoc()
)
);
// translate child
GPOS_ASSERT(1 == pexprArrayCoerceExpr->UlArity());
CExpression *pexprChild = (*pexprArrayCoerceExpr)[0];
CDXLNode *pdxlnChild = PdxlnScalar(pexprChild);
pdxlnArrayCoerceExpr->AddChild(pdxlnChild);
return pdxlnArrayCoerceExpr;
}
//---------------------------------------------------------------------------
// @function:
......
libgpopt/src/xforms/CSubqueryHandler.cpp
浏览文件 @ aad4e7fa
......@@ -57,6 +57,7 @@ const CSubqueryHandler::SOperatorHandler CSubqueryHandler::m_rgophdlr[] =
{COperator::EopScalarCast, FRecursiveHandler},
{COperator::EopScalarCoerceToDomain, FRecursiveHandler},
{COperator::EopScalarCoerceViaIO, FRecursiveHandler},
{COperator::EopScalarArrayCoerceExpr, FRecursiveHandler},
{COperator::EopScalarAggFunc, FRecursiveHandler},
{COperator::EopScalarWindowFunc, FRecursiveHandler},
{COperator::EopScalarArray, FRecursiveHandler},
......
libnaucrates/CMakeLists.txt
浏览文件 @ aad4e7fa
......@@ -345,6 +345,8 @@ add_library(naucrates
src/operators/CDXLScalarCoerceToDomain.cpp
include/naucrates/dxl/operators/CDXLScalarCoerceViaIO.h
src/operators/CDXLScalarCoerceViaIO.cpp
include/naucrates/dxl/operators/CDXLScalarArrayCoerceExpr.h
src/operators/CDXLScalarArrayCoerceExpr.cpp
include/naucrates/dxl/operators/CDXLScalarComp.h
src/operators/CDXLScalarComp.cpp
include/naucrates/dxl/operators/CDXLScalarConstValue.h
......@@ -683,6 +685,8 @@ add_library(naucrates
src/parser/CParseHandlerScalarCoerceToDomain.cpp
include/naucrates/dxl/parser/CParseHandlerScalarCoerceViaIO.h
src/parser/CParseHandlerScalarCoerceViaIO.cpp
include/naucrates/dxl/parser/CParseHandlerScalarArrayCoerceExpr.h
src/parser/CParseHandlerScalarArrayCoerceExpr.cpp
include/naucrates/dxl/parser/CParseHandlerScalarComp.h
src/parser/CParseHandlerScalarComp.cpp
include/naucrates/dxl/parser/CParseHandlerScalarConstValue.h
......
libnaucrates/include/naucrates/dxl/operators/CDXLOperator.h
浏览文件 @ aad4e7fa
......@@ -99,6 +99,7 @@ namespace gpdxl
EdxlopScalarCast,
EdxlopScalarCoerceToDomain,
EdxlopScalarCoerceViaIO,
EdxlopScalarArrayCoerceExpr,
EdxlopScalarAggref,
EdxlopScalarArrayComp,
EdxlopScalarBooleanTest,
......
libnaucrates/include/naucrates/dxl/operators/CDXLOperatorFactory.h
浏览文件 @ aad4e7fa
......@@ -322,6 +322,10 @@ namespace gpdxl
static
CDXLScalar *PdxlopCoerceViaIO(CDXLMemoryManager *pmm, const Attributes &attrs);
// create a ArrayCoerceExpr
static
CDXLScalar *PdxlopArrayCoerceExpr(CDXLMemoryManager *pmm, const Attributes &attrs);
// create a scalar identifier operator
static
CDXLScalar *PdxlopScalarIdent(CDXLMemoryManager *pmm, const Attributes &attrs);
......
libnaucrates/include/naucrates/dxl/operators/CDXLScalarArrayCoerceExpr.h 0 → 100644
浏览文件 @ aad4e7fa
//---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2017 Pivotal Inc.
//
// @filename:
// CDXLScalarArrayCoerceExpr.h
//
// @doc:
// Class for representing DXL ArrayCoerceExpr operation,
// the operator will apply type casting for each element in this array
// using the given element coercion function.
// @owner:
//
// @test:
//
//---------------------------------------------------------------------------
#ifndef GPDXL_CDXLScalarArrayCoerceExpr_H
#define GPDXL_CDXLScalarArrayCoerceExpr_H
#include "gpos/base.h"
#include "naucrates/dxl/operators/CDXLScalar.h"
#include "naucrates/md/IMDId.h"
namespace gpdxl
{
using namespace gpos;
using namespace gpmd;
//---------------------------------------------------------------------------
// @class:
// CDXLScalarArrayCoerceExpr
//
// @doc:
// Class for representing DXL array coerce operator
//---------------------------------------------------------------------------
class CDXLScalarArrayCoerceExpr : public CDXLScalar
{
private:
// catalog MDId of element coerce function
IMDId *m_pmdidElementFunc;
// catalog MDId of the result type
IMDId *m_pmdidResultType;
// output type modifications
INT m_iMod;
// conversion semantics flag to pass to func
BOOL m_fIsExplicit;
// coercion form
EdxlCoercionForm m_edxlcf;
// location of token to be coerced
INT m_iLoc;
// private copy ctor
CDXLScalarArrayCoerceExpr(const CDXLScalarArrayCoerceExpr&);
public:
CDXLScalarArrayCoerceExpr
(
IMemoryPool *pmp,
IMDId *pmdidElementFunc,
IMDId *pmdidResultType,
INT iMod,
BOOL fIsExplicit,
EdxlCoercionForm edxlcf,
INT iLoc
);
~CDXLScalarArrayCoerceExpr();
// ident accessor
virtual
Edxlopid Edxlop() const
{
return EdxlopScalarArrayCoerceExpr;
}
// return metadata id of element coerce function
IMDId *PmdidElementFunc() const
{
return m_pmdidElementFunc;
}
// return result type
IMDId *PmdidResultType() const
{
return m_pmdidResultType;
}
// return type modification
INT IMod() const
{
return m_iMod;
}
BOOL FIsExplicit() const
{
return m_fIsExplicit;
}
// return coercion form
EdxlCoercionForm Edxlcf() const
{
return m_edxlcf;
}
// return token location
INT ILoc() const
{
return m_iLoc;
}
// does the operator return a boolean result
virtual
BOOL FBoolean(CMDAccessor *pmda) const;
// name of the DXL operator name
virtual
const CWStringConst *PstrOpName() const;
// serialize operator in DXL format
virtual
void SerializeToDXL(CXMLSerializer *pxmlser, const CDXLNode *pdxln) const;
// conversion function
static
CDXLScalarArrayCoerceExpr *PdxlopConvert
(
CDXLOperator *pdxlop
)
{
GPOS_ASSERT(NULL != pdxlop);
GPOS_ASSERT(EdxlopScalarArrayCoerceExpr == pdxlop->Edxlop());
return dynamic_cast<CDXLScalarArrayCoerceExpr*>(pdxlop);
}
#ifdef GPOS_DEBUG
// checks whether the operator has valid structure, i.e. number and
// types of child nodes
virtual
void AssertValid(const CDXLNode *pdxln, BOOL fValidateChildren) const;
#endif // GPOS_DEBUG
};
}
#endif // !GPDXL_CDXLScalarArrayCoerceExpr_H
// EOF
libnaucrates/include/naucrates/dxl/operators/dxlops.h
浏览文件 @ aad4e7fa
......@@ -92,6 +92,7 @@
#include "naucrates/dxl/operators/CDXLScalarCast.h"
#include "naucrates/dxl/operators/CDXLScalarCoerceToDomain.h"
#include "naucrates/dxl/operators/CDXLScalarCoerceViaIO.h"
#include "naucrates/dxl/operators/CDXLScalarArrayCoerceExpr.h"
#include "naucrates/dxl/operators/CDXLScalarBooleanTest.h"
#include "naucrates/dxl/operators/CDXLScalarInitPlan.h"
#include "naucrates/dxl/operators/CDXLScalarArray.h"
......
libnaucrates/include/naucrates/dxl/parser/CParseHandlerFactory.h
浏览文件 @ aad4e7fa
......@@ -937,6 +937,15 @@ namespace gpdxl
CParseHandlerBase *pphRoot
);
// construct a ArrayCoerceExpr parse handler
static
CParseHandlerBase *PphScalarArrayCoerceExpr
(
IMemoryPool *pmp,
CParseHandlerManager *pphm,
CParseHandlerBase *pphRoot
);
// construct an init plan parse handler
static
CParseHandlerBase *PphScalarInitPlan
......
libnaucrates/include/naucrates/dxl/parser/CParseHandlerScalarArrayCoerceExpr.h 0 → 100644
浏览文件 @ aad4e7fa
//---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2014 Pivotal Inc.
//
// @filename:
// CParseHandlerScalarArrayCoerceExpr.h
//
// @doc:
//
// SAX parse handler class for parsing ArrayCoerceExpr operator.
//
// @owner:
//
// @test:
//
//
//---------------------------------------------------------------------------
#ifndef GPDXL_CParseHandlerScalarArrayCoerceExpr_H
#define GPDXL_CParseHandlerScalarArrayCoerceExpr_H
#include "gpos/base.h"
#include "naucrates/dxl/parser/CParseHandlerScalarOp.h"
#include "naucrates/dxl/operators/CDXLScalarArrayCoerceExpr.h"
namespace gpdxl
{
using namespace gpos;
XERCES_CPP_NAMESPACE_USE
//---------------------------------------------------------------------------
// @class:
// CParseHandlerScalarArrayCoerceExpr
//
// @doc:
// Parse handler for parsing parsing ArrayCoerceExpr operator
//
//---------------------------------------------------------------------------
class CParseHandlerScalarArrayCoerceExpr : public CParseHandlerScalarOp
{
private:
// private copy ctor
CParseHandlerScalarArrayCoerceExpr(const CParseHandlerScalarArrayCoerceExpr &);
// process the start of an element
void StartElement
(
const XMLCh* const xmlszUri, // URI of element's namespace
const XMLCh* const xmlszLocalname, // local part of element's name
const XMLCh* const xmlszQname, // element's qname
const Attributes& attr // element's attributes
);
// process the end of an element
void EndElement
(
const XMLCh* const xmlszUri, // URI of element's namespace
const XMLCh* const xmlszLocalname, // local part of element's name
const XMLCh* const xmlszQname // element's qname
);
public:
// ctor/dtor
CParseHandlerScalarArrayCoerceExpr
(
IMemoryPool *pmp,
CParseHandlerManager *pphm,
CParseHandlerBase *pphRoot
);
virtual
~CParseHandlerScalarArrayCoerceExpr(){};
};
}
#endif // GPDXL_CParseHandlerScalarArrayCoerceExpr_H
//EOF
libnaucrates/include/naucrates/dxl/parser/parsehandlers.h
浏览文件 @ aad4e7fa
......@@ -83,6 +83,7 @@
#include "naucrates/dxl/parser/CParseHandlerScalarCast.h"
#include "naucrates/dxl/parser/CParseHandlerScalarCoerceToDomain.h"
#include "naucrates/dxl/parser/CParseHandlerScalarCoerceViaIO.h"
#include "naucrates/dxl/parser/CParseHandlerScalarArrayCoerceExpr.h"
#include "naucrates/dxl/parser/CParseHandlerScalarSubquery.h"
#include "naucrates/dxl/parser/CParseHandlerScalarBitmapBoolOp.h"
......
libnaucrates/include/naucrates/dxl/xml/dxltokens.h
浏览文件 @ aad4e7fa
......@@ -163,6 +163,7 @@ namespace gpdxl
EdxltokenScalarCast,
EdxltokenScalarCoerceToDomain,
EdxltokenScalarCoerceViaIO,
EdxltokenScalarArrayCoerceExpr,
EdxltokenScalarSortCol,
EdxltokenScalarSortColList,
EdxltokenScalarGroupingColList,
......@@ -260,10 +261,12 @@ namespace gpdxl
EdxltokenConstTuple,
EdxltokenDatum,
// CoerceToDomain and CoerceViaIO related tokens
// CoerceToDomain and CoerceViaIO and ArrayCoerceExpr related tokens
EdxltokenTypeMod,
EdxltokenCoercionForm,
EdxltokenLocation,
EdxltokenElementFunc,
EdxltokenIsExplicit,
EdxltokenJoinType,
EdxltokenJoinInner,
......
libnaucrates/src/operators/CDXLOperatorFactory.cpp
浏览文件 @ aad4e7fa
......@@ -1083,6 +1083,33 @@ CDXLOperatorFactory::PdxlopCoerceViaIO
return GPOS_NEW(pmp) CDXLScalarCoerceViaIO(pmp, pmdidType, iMod, (EdxlCoercionForm) ulCoercionForm, iLoc);
}
//---------------------------------------------------------------------------
// @function:
// CDXLOperatorFactory::PdxlopArrayCoerceExpr
//
// @doc:
// Construct a scalar array coerce expression
//
//---------------------------------------------------------------------------
CDXLScalar *
CDXLOperatorFactory::PdxlopArrayCoerceExpr
(
CDXLMemoryManager *pmm,
const Attributes &attrs
)
{
IMemoryPool *pmp = pmm->Pmp();
IMDId *pmdidElementFunc = PmdidFromAttrs(pmm, attrs, EdxltokenElementFunc, EdxltokenScalarArrayCoerceExpr);
IMDId *pmdidType = PmdidFromAttrs(pmm, attrs, EdxltokenTypeId, EdxltokenScalarArrayCoerceExpr);
INT iMod = IValueFromAttrs(pmm, attrs, EdxltokenTypeMod, EdxltokenScalarArrayCoerceExpr);
BOOL fIsExplicit = FValueFromAttrs(pmm, attrs, EdxltokenIsExplicit, EdxltokenScalarArrayCoerceExpr);
ULONG ulCoercionForm = UlValueFromAttrs(pmm, attrs, EdxltokenCoercionForm, EdxltokenScalarArrayCoerceExpr);
INT iLoc = IValueFromAttrs(pmm, attrs, EdxltokenLocation, EdxltokenScalarArrayCoerceExpr);
return GPOS_NEW(pmp) CDXLScalarArrayCoerceExpr(pmp, pmdidElementFunc, pmdidType, iMod, fIsExplicit, (EdxlCoercionForm) ulCoercionForm, iLoc);
}
//---------------------------------------------------------------------------
// @function:
// CDXLOperatorFactory::PdxlopConstValue
......
libnaucrates/src/operators/CDXLScalarArrayCoerceExpr.cpp 0 → 100644
浏览文件 @ aad4e7fa
//---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2017 Pivotal Inc.
//
// @filename:
// CDXLScalarArrayCoerceExpr.cpp
//
// @doc:
// Implementation of DXL scalar array coerce expr
//
// @owner:
//
// @test:
//
//---------------------------------------------------------------------------
#include "naucrates/dxl/operators/CDXLScalarArrayCoerceExpr.h"
#include "naucrates/dxl/operators/CDXLNode.h"
#include "naucrates/dxl/xml/dxltokens.h"
#include "naucrates/dxl/xml/CXMLSerializer.h"
#include "gpopt/mdcache/CMDAccessor.h"
using namespace gpopt;
using namespace gpos;
using namespace gpdxl;
//---------------------------------------------------------------------------
// @function:
// CDXLScalarArrayCoerceExpr::CDXLScalarArrayCoerceExpr
//
// @doc:
// Ctor
//
//---------------------------------------------------------------------------
CDXLScalarArrayCoerceExpr::CDXLScalarArrayCoerceExpr
(
IMemoryPool *pmp,
IMDId *pmdidElementFunc,
IMDId *pmdidResultType,
INT iMod,
BOOL fIsExplicit,
EdxlCoercionForm edxlcf,
INT iLoc
)
:
CDXLScalar(pmp),
m_pmdidElementFunc(pmdidElementFunc),
m_pmdidResultType(pmdidResultType),
m_iMod(iMod),
m_fIsExplicit(fIsExplicit),
m_edxlcf(edxlcf),
m_iLoc(iLoc)
{
GPOS_ASSERT(NULL != pmdidElementFunc);
GPOS_ASSERT(NULL != pmdidResultType);
GPOS_ASSERT(pmdidResultType->FValid());
}
//---------------------------------------------------------------------------
// @function:
// CDXLScalarArrayCoerceExpr::~CDXLScalarArrayCoerceExpr
//
// @doc:
// Dtor
//
//---------------------------------------------------------------------------
CDXLScalarArrayCoerceExpr::~CDXLScalarArrayCoerceExpr()
{
m_pmdidElementFunc->Release();
m_pmdidResultType->Release();
}
//---------------------------------------------------------------------------
// @function:
// CDXLScalarArrayCoerceExpr::FBoolean
//
// @doc:
// Does the operator return a boolean result
//
//---------------------------------------------------------------------------
BOOL
CDXLScalarArrayCoerceExpr::FBoolean
(
CMDAccessor *pmda
)
const
{
return (IMDType::EtiBool == pmda->Pmdtype(m_pmdidResultType)->Eti());
}
//---------------------------------------------------------------------------
// @function:
// CDXLScalarArrayCoerceExpr::PstrOpName
//
// @doc:
// Operator name
//
//---------------------------------------------------------------------------
const CWStringConst *
CDXLScalarArrayCoerceExpr::PstrOpName() const
{
return CDXLTokens::PstrToken(EdxltokenScalarArrayCoerceExpr);
}
//---------------------------------------------------------------------------
// @function:
// CDXLScalarArrayCoerceExpr::SerializeToDXL
//
// @doc:
// Serialize operator in DXL format
//
//---------------------------------------------------------------------------
void
CDXLScalarArrayCoerceExpr::SerializeToDXL
(
CXMLSerializer *pxmlser,
const CDXLNode *pdxln
)
const
{
const CWStringConst *pstrElemName = PstrOpName();
pxmlser->OpenElement(CDXLTokens::PstrToken(EdxltokenNamespacePrefix), pstrElemName);
m_pmdidElementFunc->Serialize(pxmlser, CDXLTokens::PstrToken(EdxltokenElementFunc));
m_pmdidResultType->Serialize(pxmlser, CDXLTokens::PstrToken(EdxltokenTypeId));
pxmlser->AddAttribute(CDXLTokens::PstrToken(EdxltokenTypeMod), m_iMod);
pxmlser->AddAttribute(CDXLTokens::PstrToken(EdxltokenIsExplicit), m_fIsExplicit);
pxmlser->AddAttribute(CDXLTokens::PstrToken(EdxltokenCoercionForm), (ULONG) m_edxlcf);
pxmlser->AddAttribute(CDXLTokens::PstrToken(EdxltokenLocation), m_iLoc);
pdxln->SerializeChildrenToDXL(pxmlser);
pxmlser->CloseElement(CDXLTokens::PstrToken(EdxltokenNamespacePrefix), pstrElemName);
}
#ifdef GPOS_DEBUG
//---------------------------------------------------------------------------
// @function:
// CDXLScalarArrayCoerceExpr::AssertValid
//
// @doc:
// Checks whether operator node is well-structured
//
//---------------------------------------------------------------------------
void
CDXLScalarArrayCoerceExpr::AssertValid
(
const CDXLNode *pdxln,
BOOL fValidateChildren
) const
{
GPOS_ASSERT(1 == pdxln->UlArity());
CDXLNode *pdxlnChild = (*pdxln)[0];
GPOS_ASSERT(EdxloptypeScalar == pdxlnChild->Pdxlop()->Edxloperatortype());
if (fValidateChildren)
{
pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren);
}
}
#endif // GPOS_DEBUG
// EOF
libnaucrates/src/parser/CParseHandlerFactory.cpp
浏览文件 @ aad4e7fa
......@@ -185,6 +185,7 @@ CParseHandlerFactory::Init
{EdxltokenScalarCast, &PphScalarCast},
{EdxltokenScalarCoerceToDomain, PphScalarCoerceToDomain},
{EdxltokenScalarCoerceViaIO, PphScalarCoerceViaIO},
{EdxltokenScalarArrayCoerceExpr, PphScalarArrayCoerceExpr},
{EdxltokenScalarHashExpr, &PphHashExpr},
{EdxltokenScalarHashCondList, &PphCondList},
{EdxltokenScalarMergeCondList, &PphCondList},
......@@ -2032,6 +2033,25 @@ CParseHandlerFactory::PphScalarCoerceViaIO
return GPOS_NEW(pmp) CParseHandlerScalarCoerceViaIO(pmp, pphm, pphRoot);
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerFactory::PphScalarArrayCoerceExpr
//
// @doc:
// Creates a parse handler for parsing an array coerce expression operator
//
//---------------------------------------------------------------------------
CParseHandlerBase *
CParseHandlerFactory::PphScalarArrayCoerceExpr
(
IMemoryPool *pmp,
CParseHandlerManager *pphm,
CParseHandlerBase *pphRoot
)
{
return GPOS_NEW(pmp) CParseHandlerScalarArrayCoerceExpr(pmp, pphm, pphRoot);
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerFactory::PphScalarInitPlan
......
libnaucrates/src/parser/CParseHandlerScalarArrayCoerceExpr.cpp 0 → 100644
浏览文件 @ aad4e7fa
//---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2014 Pivotal Inc.
//
// @filename:
// CParseHandlerScalarArrayCoerceExpr.cpp
//
// @doc:
//
// Implementation of the SAX parse handler class for parsing scalar array coerce expression operator.
//
// @owner:
//
// @test:
//
//
//---------------------------------------------------------------------------
#include "naucrates/dxl/parser/CParseHandlerScalarOp.h"
#include "naucrates/dxl/parser/CParseHandlerFactory.h"
#include "naucrates/dxl/CDXLUtils.h"
#include "naucrates/dxl/operators/CDXLOperatorFactory.h"
#include "naucrates/dxl/parser/CParseHandlerScalarArrayCoerceExpr.h"
using namespace gpdxl;
XERCES_CPP_NAMESPACE_USE
//---------------------------------------------------------------------------
// @function:
// CParseHandlerScalarArrayCoerceExpr::CParseHandlerScalarArrayCoerceExpr
//
// @doc:
// Ctor
//
//---------------------------------------------------------------------------
CParseHandlerScalarArrayCoerceExpr::CParseHandlerScalarArrayCoerceExpr
(
IMemoryPool *pmp,
CParseHandlerManager *pphm,
CParseHandlerBase *pphRoot
)
:
CParseHandlerScalarOp(pmp, pphm, pphRoot)
{
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerScalarArrayCoerceExpr::StartElement
//
// @doc:
// Processes a Xerces start element event
//
//---------------------------------------------------------------------------
void
CParseHandlerScalarArrayCoerceExpr::StartElement
(
const XMLCh* const, // xmlszUri,
const XMLCh* const xmlszLocalname,
const XMLCh* const, // xmlszQname
const Attributes& attrs
)
{
if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarArrayCoerceExpr), xmlszLocalname))
{
if (NULL != m_pdxln)
{
CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname);
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz());
}
// parse and create scalar coerce
CDXLScalarArrayCoerceExpr *pdxlop = (CDXLScalarArrayCoerceExpr*) CDXLOperatorFactory::PdxlopArrayCoerceExpr(m_pphm->Pmm(), attrs);
m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop);
// parse handler for child scalar node
CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_pphm, this);
m_pphm->ActivateParseHandler(pphChild);
// store parse handler
this->Append(pphChild);
}
else
{
CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname);
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz());
}
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerScalarArrayCoerceExpr::EndElement
//
// @doc:
// Processes a Xerces end element event
//
//---------------------------------------------------------------------------
void
CParseHandlerScalarArrayCoerceExpr::EndElement
(
const XMLCh* const, // xmlszUri,
const XMLCh* const xmlszLocalname,
const XMLCh* const // xmlszQname
)
{
if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarArrayCoerceExpr), xmlszLocalname))
{
CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname);
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz());
}
GPOS_ASSERT(1 == this->UlLength());
// add constructed child from child parse handlers
CParseHandlerScalarOp *pphChild = dynamic_cast<CParseHandlerScalarOp*>((*this)[0]);
AddChildFromParseHandler(pphChild);
// deactivate handler
m_pphm->DeactivateHandler();
}
// EOF
libnaucrates/src/xml/dxltokens.cpp
浏览文件 @ aad4e7fa
......@@ -205,6 +205,7 @@ CDXLTokens::Init
{EdxltokenScalarCast, GPOS_WSZ_LIT("Cast")},
{EdxltokenScalarCoerceToDomain, GPOS_WSZ_LIT("CoerceToDomain")},
{EdxltokenScalarCoerceViaIO, GPOS_WSZ_LIT("CoerceViaIO")},
{EdxltokenScalarArrayCoerceExpr, GPOS_WSZ_LIT("ArrayCoerceExpr")},
{EdxltokenScalarSortCol, GPOS_WSZ_LIT("SortingColumn")},
{EdxltokenScalarSortColList, GPOS_WSZ_LIT("SortingColumnList")},
{EdxltokenScalarGroupingColList, GPOS_WSZ_LIT("GroupingColumns")},
......@@ -267,6 +268,8 @@ CDXLTokens::Init
{EdxltokenTypeMod, GPOS_WSZ_LIT("TypeModification")},
{EdxltokenCoercionForm, GPOS_WSZ_LIT("CoercionForm")},
{EdxltokenLocation, GPOS_WSZ_LIT("Location")},
{EdxltokenElementFunc, GPOS_WSZ_LIT("ElementFunc")},
{EdxltokenIsExplicit, GPOS_WSZ_LIT("IsExplicit")},
{EdxltokenJoinType, GPOS_WSZ_LIT("JoinType")},
{EdxltokenJoinInner, GPOS_WSZ_LIT("Inner")},
......
server/src/unittest/gpopt/minidump/CICGTest.cpp
浏览文件 @ aad4e7fa
......@@ -40,6 +40,7 @@ ULONG CICGTest::m_ulNegativeIndexApplyTestCounter = 0;
// minidump files
const CHAR *rgszFileNames[] =
{
"../data/dxl/minidump/ArrayCoerceExpr.mdp",
"../data/dxl/minidump/DisableLargeTableBroadcast.mdp",
"../data/dxl/minidump/InferPredicatesForLimit.mdp",
"../data/dxl/minidump/OR-WithIsNullPred.mdp",
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或