# Licensed Materials - Property of IBM
# IBM Cognos Products: OQP
# (C) Copyright IBM Corp. 2005, 2022
# US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM corp.

#
# Product information.
#

#
# Delimiters.
#

#
# Various limits.
#
limits.maxStatements=1
limits.castClobToVarcharMaxSize=32000
limits.maxDecimalPrecision=38

#
# General settings.
#
general.nullsOrdering=true
general.nullsOrderingInWindowSpecification=true

#
# RTC 61393
# Indicates whether to set nulls ok indicator to true when processing JDBC result set metadata.
# This is set to true only if the value returned by invoking java.sql.ResultSetMetadata.isNullable() is
# possibly incorrect.
#
general.forceNullsOk=true

#
# Override sampling policy with a different one.
# 1. tablesample accepting values such as BERNOULLI or SYSTEM
# 2. rowsample accepting values such as NTH or RANDOM
#
sampling.tablesample=
sampling.rowsample=RANDOM

#
# Various features.
#
supports.expressionsInINPredicate=false
supports.orderByAlias=false
supports.orderByName=false
supports.stitchJoins=false
supports.nestedWithClause=false
supports.subqueriesInCase=false
supports.recursiveWithClause=false
supports.booleanExpressionsInSelectList=false
supports.orderByInDerivedTable=false
supports.callProcedureInDerivedTable=false
supports.top.distinct=false
supports.top.set=false
supports.top.0=false

#casting with formatting pattern support
supports.formatters.string_to_date=false
supports.formatters.string_to_time=false
supports.formatters.string_to_time_with_time_zone=false
supports.formatters.string_to_timestamp=false
supports.formatters.string_to_timestamp_with_time_zone=false

#
# Command.
#

#
# Tables.
#
tables.lateral.derived=false

#
# Constructors.
#
constructors.table=false
constructors.row=false
constructors.array=false

#
# Clauses.
#
clauses.With=
clauses.Top=TOP %1$s
clauses.Top.Position=distinct.top
clauses.At=
clauses.Window=
clauses.WithRecursive=
clauses.TableSampleSystem=
clauses.TableSampleBernoulli=
clauses.ForSystemTimeAsOf=
clauses.ForSystemTimeFrom=
clauses.ForSystemTimeBetween=

#
# Joins.
#

#
# Set operators.
#

#
# Logical operators.
#
operators.logical.Is=
operators.logical.IsNot=

#
# Arithmetic operators.
#
operators.arithmetic.Subtract[date,date]=((%1$s) - (%2$s) DAY(4))
operators.arithmetic.Subtract[time,time]=((%1$s) - (%2$s) HOUR(4) TO SECOND(6))
operators.arithmetic.Subtract[time,time_with_time_zone]=
operators.arithmetic.Subtract[time_with_time_zone,time]=
operators.arithmetic.Subtract[time_with_time_zone,time_with_time_zone]=((%1$s) - (%2$s) HOUR(4) TO SECOND(6))
operators.arithmetic.Subtract[timestamp,timestamp]=((%1$s) - (%2$s) DAY(4) TO SECOND(6))
operators.arithmetic.Subtract[timestamp,timestamp_with_time_zone]=
operators.arithmetic.Subtract[timestamp_with_time_zone,timestamp]=
operators.arithmetic.Subtract[timestamp_with_time_zone,timestamp_with_time_zone]=((%1$s) - (%2$s) DAY(4) TO SECOND(6))

#
# Group By Operators
#
operators.groupBy.Rollup=
operators.groupBy.Cube=
operators.groupBy.GroupingSets=

#
# Comparison predicates.
#
predicates.comparison.LessThan[interval_year_month,interval_year_month]=
predicates.comparison.LessThan[interval_year_to_month,interval_year_to_month]=%1$s < %2$s
predicates.comparison.LessThan[interval_year,interval_year]=%1$s < %2$s
predicates.comparison.LessThan[interval_month,interval_month]=%1$s < %2$s
predicates.comparison.LessThan[interval_day_time,interval_day_time]=
predicates.comparison.LessThan[interval_day_to_second,interval_day_to_second]=%1$s < %2$s
predicates.comparison.LessThan[interval_day_to_minute,interval_day_to_minute]=%1$s < %2$s
predicates.comparison.LessThan[interval_day_to_hour,interval_day_to_hour]=%1$s < %2$s
predicates.comparison.LessThan[interval_day,interval_day]=%1$s < %2$s
predicates.comparison.LessThan[interval_hour_to_second,interval_hour_to_second]=%1$s < %2$s
predicates.comparison.LessThan[interval_hour_to_minute,interval_hour_to_minute]=%1$s < %2$s
predicates.comparison.LessThan[interval_hour,interval_hour]=%1$s < %2$s
predicates.comparison.LessThan[interval_minute_to_second,interval_minute_to_second]=%1$s < %2$s
predicates.comparison.LessThan[interval_minute,interval_minute]=%1$s < %2$s
predicates.comparison.LessThan[interval_second,interval_second]=%1$s < %2$s
predicates.comparison.LessThan[date,timestamp]=
predicates.comparison.LessThan[date,timestamp_with_time_zone]=
predicates.comparison.LessThan[timestamp,date]=
predicates.comparison.LessThan[timestamp_with_time_zone,date]=
predicates.comparison.LessThan[time,time_with_time_zone]=
predicates.comparison.LessThan[time_with_time_zone,time]=
predicates.comparison.LessThan[timestamp,timestamp_with_time_zone]=
predicates.comparison.LessThan[timestamp_with_time_zone,timestamp]=

predicates.comparison.LessThanOrEquals[interval_year_month,interval_year_month]=
predicates.comparison.LessThanOrEquals[interval_year_to_month,interval_year_to_month]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_year,interval_year]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_month,interval_month]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_day_time,interval_day_time]=
predicates.comparison.LessThanOrEquals[interval_day_to_second,interval_day_to_second]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_day_to_minute,interval_day_to_minute]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_day_to_hour,interval_day_to_hour]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_day,interval_day]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_hour_to_second,interval_hour_to_second]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_hour_to_minute,interval_hour_to_minute]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_hour,interval_hour]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_minute_to_second,interval_minute_to_second]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_minute,interval_minute]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[interval_second,interval_second]=%1$s <= %2$s
predicates.comparison.LessThanOrEquals[date,timestamp]=
predicates.comparison.LessThanOrEquals[date,timestamp_with_time_zone]=
predicates.comparison.LessThanOrEquals[timestamp,date]=
predicates.comparison.LessThanOrEquals[timestamp_with_time_zone,date]=
predicates.comparison.LessThanOrEquals[time,time_with_time_zone]=
predicates.comparison.LessThanOrEquals[time_with_time_zone,time]=
predicates.comparison.LessThanOrEquals[timestamp,timestamp_with_time_zone]=
predicates.comparison.LessThanOrEquals[timestamp_with_time_zone,timestamp]=

predicates.comparison.Equals[interval_year_month,interval_year_month]=
predicates.comparison.Equals[interval_year_to_month,interval_year_to_month]=%1$s = %2$s
predicates.comparison.Equals[interval_year,interval_year]=%1$s = %2$s
predicates.comparison.Equals[interval_month,interval_month]=%1$s = %2$s
predicates.comparison.Equals[interval_day_time,interval_day_time]=
predicates.comparison.Equals[interval_day_to_second,interval_day_to_second]=%1$s = %2$s
predicates.comparison.Equals[interval_day_to_minute,interval_day_to_minute]=%1$s = %2$s
predicates.comparison.Equals[interval_day_to_hour,interval_day_to_hour]=%1$s = %2$s
predicates.comparison.Equals[interval_day,interval_day]=%1$s = %2$s
predicates.comparison.Equals[interval_hour_to_second,interval_hour_to_second]=%1$s = %2$s
predicates.comparison.Equals[interval_hour_to_minute,interval_hour_to_minute]=%1$s = %2$s
predicates.comparison.Equals[interval_hour,interval_hour]=%1$s = %2$s
predicates.comparison.Equals[interval_minute_to_second,interval_minute_to_second]=%1$s = %2$s
predicates.comparison.Equals[interval_minute,interval_minute]=%1$s = %2$s
predicates.comparison.Equals[interval_second,interval_second]=%1$s = %2$s
predicates.comparison.Equals[date,timestamp]=
predicates.comparison.Equals[date,timestamp_with_time_zone]=
predicates.comparison.Equals[timestamp,date]=
predicates.comparison.Equals[timestamp_with_time_zone,date]=
predicates.comparison.Equals[time,time_with_time_zone]=
predicates.comparison.Equals[time_with_time_zone,time]=
predicates.comparison.Equals[timestamp,timestamp_with_time_zone]=
predicates.comparison.Equals[timestamp_with_time_zone,timestamp]=

predicates.comparison.NotEquals[interval_year_month,interval_year_month]=
predicates.comparison.NotEquals[interval_year_to_month,interval_year_to_month]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_year,interval_year]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_month,interval_month]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_day_time,interval_day_time]=
predicates.comparison.NotEquals[interval_day_to_second,interval_day_to_second]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_day_to_minute,interval_day_to_minute]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_day_to_hour,interval_day_to_hour]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_day,interval_day]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_hour_to_second,interval_hour_to_second]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_hour_to_minute,interval_hour_to_minute]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_hour,interval_hour]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_minute_to_second,interval_minute_to_second]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_minute,interval_minute]=%1$s <> %2$s
predicates.comparison.NotEquals[interval_second,interval_second]=%1$s <> %2$s
predicates.comparison.NotEquals[date,timestamp]=
predicates.comparison.NotEquals[date,timestamp_with_time_zone]=
predicates.comparison.NotEquals[timestamp,date]=
predicates.comparison.NotEquals[timestamp_with_time_zone,date]=
predicates.comparison.NotEquals[time,time_with_time_zone]=
predicates.comparison.NotEquals[time_with_time_zone,time]=
predicates.comparison.NotEquals[timestamp,timestamp_with_time_zone]=
predicates.comparison.NotEquals[timestamp_with_time_zone,timestamp]=

predicates.comparison.GreaterThan[interval_year_month,interval_year_month]=
predicates.comparison.GreaterThan[interval_year_to_month,interval_year_to_month]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_year,interval_year]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_month,interval_month]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_day_time,interval_day_time]=
predicates.comparison.GreaterThan[interval_day_to_second,interval_day_to_second]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_day_to_minute,interval_day_to_minute]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_day_to_hour,interval_day_to_hour]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_day,interval_day]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_hour_to_second,interval_hour_to_second]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_hour_to_minute,interval_hour_to_minute]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_hour,interval_hour]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_minute_to_second,interval_minute_to_second]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_minute,interval_minute]=%1$s > %2$s
predicates.comparison.GreaterThan[interval_second,interval_second]=%1$s > %2$s
predicates.comparison.GreaterThan[date,timestamp]=
predicates.comparison.GreaterThan[date,timestamp_with_time_zone]=
predicates.comparison.GreaterThan[timestamp,date]=
predicates.comparison.GreaterThan[timestamp_with_time_zone,date]=
predicates.comparison.GreaterThan[time,time_with_time_zone]=
predicates.comparison.GreaterThan[time_with_time_zone,time]=
predicates.comparison.GreaterThan[timestamp,timestamp_with_time_zone]=
predicates.comparison.GreaterThan[timestamp_with_time_zone,timestamp]=

predicates.comparison.GreaterThanOrEquals[interval_year_month,interval_year_month]=
predicates.comparison.GreaterThanOrEquals[interval_year_to_month,interval_year_to_month]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_year,interval_year]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_month,interval_month]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_day_time,interval_day_time]=
predicates.comparison.GreaterThanOrEquals[interval_day_to_second,interval_day_to_second]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_day_to_minute,interval_day_to_minute]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_day_to_hour,interval_day_to_hour]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_day,interval_day]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_hour_to_second,interval_hour_to_second]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_hour_to_minute,interval_hour_to_minute]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_hour,interval_hour]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_minute_to_second,interval_minute_to_second]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_minute,interval_minute]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[interval_second,interval_second]=%1$s >= %2$s
predicates.comparison.GreaterThanOrEquals[date,timestamp]=
predicates.comparison.GreaterThanOrEquals[date,timestamp_with_time_zone]=
predicates.comparison.GreaterThanOrEquals[timestamp,date]=
predicates.comparison.GreaterThanOrEquals[timestamp_with_time_zone,date]=
predicates.comparison.GreaterThanOrEquals[time,time_with_time_zone]=
predicates.comparison.GreaterThanOrEquals[time_with_time_zone,time]=
predicates.comparison.GreaterThanOrEquals[timestamp,timestamp_with_time_zone]=
predicates.comparison.GreaterThanOrEquals[timestamp_with_time_zone,timestamp]=

#
# Various predicates.
#
predicates.Between[interval_year_month,interval_year_month,interval_year_month]=
predicates.Between[interval_year_to_month,interval_year_to_month,interval_year_to_month]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_year,interval_year,interval_year]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_month,interval_month,interval_month]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_day_time,interval_day_time,interval_day_time]=
predicates.Between[interval_day_to_second,interval_day_to_second,interval_day_to_second]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_day_to_minute,interval_day_to_minute,interval_day_to_minute]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_day_to_hour,interval_day_to_hour,interval_day_to_hour]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_day,interval_day,interval_day]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_hour_to_second,interval_hour_to_second,interval_hour_to_second]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_hour_to_minute,interval_hour_to_minute,interval_hour_to_minute]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_hour,interval_hour,interval_hour]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_minute_to_second,interval_minute_to_second,interval_minute_to_second]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_minute,interval_minute,interval_minute]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[interval_second,interval_second,interval_second]=%1$s BETWEEN %2$s AND %3$s
predicates.Between[date,timestamp,any]=
predicates.Between[date,any,timestamp]=
predicates.Between[date,timestamp_with_time_zone,any]=
predicates.Between[date,any,timestamp_with_time_zone]=
predicates.Between[timestamp,date,any]=
predicates.Between[timestamp,any,date]=
predicates.Between[timestamp_with_time_zone,date,any]=
predicates.Between[timestamp_with_time_zone,any,date]=

predicates.In[interval_year_month,interval_year_month]=
predicates.In[interval_year_to_month,interval_year_to_month]=%1$s IN (%2$s)
predicates.In[interval_year,interval_year]=%1$s IN (%2$s)
predicates.In[interval_month,interval_month]=%1$s IN (%2$s)
predicates.In[interval_day_time,interval_day_time]=
predicates.In[interval_day_to_second,interval_day_to_second]=%1$s IN (%2$s)
predicates.In[interval_day_to_minute,interval_day_to_minute]=%1$s IN (%2$s)
predicates.In[interval_day_to_hour,interval_day_to_hour]=%1$s IN (%2$s)
predicates.In[interval_day,interval_day]=%1$s IN (%2$s)
predicates.In[interval_hour_to_second,interval_hour_to_second]=%1$s IN (%2$s)
predicates.In[interval_hour_to_minute,interval_hour_to_minute]=%1$s IN (%2$s)
predicates.In[interval_hour,interval_hour]=%1$s IN (%2$s)
predicates.In[interval_minute_to_second,interval_minute_to_second]=%1$s IN (%2$s)
predicates.In[interval_minute,interval_minute]=%1$s IN (%2$s)
predicates.In[interval_second,interval_second]=%1$s IN (%2$s)
predicates.In[date,timestamp]=
predicates.In[date,timestamp_with_time_zone]=
predicates.In[timestamp,date]=
predicates.In[timestamp_with_time_zone,date]=

predicates.IsDistinctFrom[any,any]=(%1$s IS NULL AND %2$s IS NOT NULL) OR (%1$s IS NOT NULL AND %2$s IS NULL) OR %1$s <> %2$s
predicates.IsNotDistinctFrom[any,any]=%1$s = %2$s OR (%1$s IS NULL AND %2$s IS NULL)
predicates.LikeRegex=
predicates.LikeRegex.flag=
predicates.Similar=
predicates.Similar.escape=

#
# Expressions.
#

#
# Cast expression.
#
expressions.Cast[clob,char]=CAST(%1$s AS %2$s)
expressions.Cast[clob,varchar]=CAST(%1$s AS %2$s)
expressions.Cast[clob,any]=
expressions.Cast[date,clob]=
expressions.Cast[date,text]=
expressions.Cast[datetime,time_with_time_zone]=
expressions.Cast[datetime,timestamp_with_time_zone]=
expressions.Cast[time,clob]=
expressions.Cast[time_with_time_zone,clob]=
expressions.Cast[time_with_time_zone,datetime]=
expressions.Cast[timestamp,clob]=
expressions.Cast[timestamp_with_time_zone,clob]=
expressions.Cast[timestamp_with_time_zone,datetime]=
expressions.Cast[interval_day_to_hour,interval_second]=
expressions.Cast[interval_day_to_minute,interval_second]=
expressions.Cast[interval_day_to_second,interval_second]=
expressions.Cast[interval_year,clob]=
expressions.Cast[interval_year_to_month,clob]=
expressions.Cast[interval_month,clob]=
expressions.Cast[decimal,clob]=
expressions.Cast[double,clob]=
expressions.Cast[float,clob]=
expressions.Cast[integer,clob]=
expressions.Cast[smallint,clob]=
expressions.Cast[char,clob]=
expressions.Cast[varchar,clob]=

# Minimum number of arguments for Coalesce function.
expressions.Coalesce.minArgs=2

#
# Extract expression.
#
expressions.Extract.EPOCH[any]=

#
# Trim expression.
#

#
# Windowed aggregates (SQL/OLAP).
#
olap.Count[blob]=
olap.Count[xml]=
olap.Rank[]=RANK()
olap.DenseRank[]=DENSE_RANK()
olap.CumeDist[]=CUME_DIST()
olap.FirstValue[any]=FIRST_VALUE(%1$s)
olap.FirstValue[date]=
olap.LastValue[any]=LAST_VALUE(%1$s)
olap.LastValue[date]=
olap.NTile[any]=
olap.RatioToReport[any]=
olap.Tertile[]=
olap.Difference[any]=
olap.PercentileCont[any,any]=
olap.PercentileDisc[any,any]=
olap.Median[any]=

# Teradata does not implicitly cast the type for default value
# Offset can only be an integeral type

olap.Lag[any]=LAG(%1$s)
olap.Lag[blob]=
olap.Lag[xml]=

olap.Lag[any,any]=LAG(%1$s, %2$s)
olap.Lag[any,decimal]=
olap.Lag[any,double]=
olap.Lag[any,float]=
olap.Lag[blob,any]=
olap.Lag[xml,any]=

olap.Lag[any,any,any]=
olap.Lag[any,decimal,any]=
olap.Lag[any,double,any]=
olap.Lag[any,float,any]=
olap.Lag[smallint,any,any]=LAG(%1$s, %2$s, cast(%3$s as smallint))
olap.Lag[integer,any,any]=LAG(%1$s, %2$s, cast(%3$s as integer))
olap.Lag[long,any,any]=LAG(%1$s, %2$s, cast(%3$s as bigint))
olap.Lag[double,any,any]=LAG(%1$s, %2$s, cast(%3$s as double precision))
olap.Lag[float,any,any]=LAG(%1$s, %2$s, cast(%3$s as float))
olap.Lag[date,any,date]=LAG(%1$s, %2$s, %3$s)
olap.Lag[time,any,time]=LAG(%1$s, %2$s, cast(%3$s as time))
olap.Lag[timestamp,any,timestamp]=LAG(%1$s, %2$s, cast(%3$s as timestamp))

olap.Lag[any,any,any,any]=
olap.Lag[any,decimal,any,any]=
olap.Lag[any,double,any,any]=
olap.Lag[any,float,any,any]=
olap.Lag[smallint,any,any,any]=LAG(%1$s, %2$s, cast(%3$s as smallint)) %4$s
olap.Lag[integer,any,any,any]=LAG(%1$s, %2$s, cast(%3$s as integer)) %4$s
olap.Lag[long,any,any,any]=LAG(%1$s, %2$s, cast(%3$s as bigint)) %4$s
olap.Lag[double,any,any,any]=LAG(%1$s, %2$s, cast(%3$s as double precision)) %4$s
olap.Lag[float,any,any,any]=LAG(%1$s, %2$s, cast(%3$s as float)) %4$s
olap.Lag[date,any,date,any]=LAG(%1$s, %2$s, %3$s) %4$s
olap.Lag[time,any,time,any]=LAG(%1$s, %2$s, cast(%3$s as time)) %4$s
olap.Lag[timestamp,any,timestamp,any]=LAG(%1$s, %2$s, cast(%3$s as timestamp))  %4$s

olap.Lead[any]=LEAD(%1$s)
olap.Lead[blob]=
olap.Lead[xml]=

olap.Lead[any,any]=LEAD(%1$s, %2$s)
olap.Lead[any,decimal]=
olap.Lead[any,double]=
olap.Lead[any,float]=
olap.Lead[blob,any]=
olap.Lead[xml,any]=

olap.Lead[any,any,any]=
olap.Lead[any,decimal,any]=
olap.Lead[any,double,any]=
olap.Lead[any,float,any]=
olap.Lead[smallint,any,any]=LEAD(%1$s, %2$s, cast(%3$s as smallint))
olap.Lead[integer,any,any]=LEAD(%1$s, %2$s, cast(%3$s as integer))
olap.Lead[long,any,any]=LEAD(%1$s, %2$s, cast(%3$s as bigint))
olap.Lead[double,any,any]=LEAD(%1$s, %2$s, cast(%3$s as double precision))
olap.Lead[float,any,any]=LEAD(%1$s, %2$s, cast(%3$s as float))
olap.Lead[date,any,date]=LEAD(%1$s, %2$s, %3$s)
olap.Lead[time,any,time]=LEAD(%1$s, %2$s, cast(%3$s as time))
olap.Lead[timestamp,any,timestamp]=LEAD(%1$s, %2$s, cast(%3$s as timestamp))

olap.Lead[any,any,any,any]=
olap.Lead[any,decimal,any,any]=
olap.Lead[any,double,any,any]=
olap.Lead[any,float,any,any]=
olap.Lead[smallint,any,any,any]=LEAD(%1$s, %2$s, cast(%3$s as smallint)) %4$s
olap.Lead[integer,any,any,any]=LEAD(%1$s, %2$s, cast(%3$s as integer)) %4$s
olap.Lead[long,any,any,any]=LEAD(%1$s, %2$s, cast(%3$s as bigint)) %4$s
olap.Lead[double,any,any,any]=LEAD(%1$s, %2$s, cast(%3$s as double precision)) %4$s
olap.Lead[float,any,any,any]=LEAD(%1$s, %2$s, cast(%3$s as float)) %4$s
olap.Lead[date,any,date,any]=LEAD(%1$s, %2$s, %3$s) %4$s
olap.Lead[time,any,time,any]=LEAD(%1$s, %2$s, cast(%3$s as time)) %4$s
olap.Lead[timestamp,any,timestamp,any]=LEAD(%1$s, %2$s, cast(%3$s as timestamp))  %4$s

olap.NthValue[any,any]=
olap.NthValue[any,any,any]=
olap.NthValue[any,any,any,any]=
olap.Collect[any]=

#
# Window clause.
#

#
# Olap (distinct).
#
olap.Max.distinct[any]=
olap.Min.distinct[any]=
olap.Sum.distinct[any]=
olap.Avg.distinct[any]=
olap.Count.distinct[any]=

#
# Aggregates.
#
aggregates.Count[any]=CAST(COUNT(%1$s) AS DECIMAL(15,0))
aggregates.Count[xml]=
aggregates.CountStar[]=CAST(COUNT(*) AS DECIMAL(15,0))
aggregates.CumeDistH[any,any]=
aggregates.PercentileCont[any,any]=PERCENTILE_CONT(%1$s) WITHIN GROUP (ORDER BY %2$s)
aggregates.PercentileDisc[any,any]=PERCENTILE_DISC(%1$s) WITHIN GROUP (ORDER BY %2$s)
aggregates.Median[any]=PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY %1$s)
aggregates.ArrayAgg[any]=
aggregates.ArrayAgg[any,any]=
aggregates.Collect[any]=
aggregates.ApproxCountDistinct[any]=

#
# Aggregates (distinct).
#
aggregates.Count.distinct[blob]=

#
# JSON aggregates.
#
aggregates.JSONArrayAgg=
aggregates.JSONObjectAgg=

#
# Linear regression aggregates.
#

#
# Character scalar functions.
#
functions.BitLength[any]=(OCTET_LENGTH(%1$s) * 8)
functions.Position[any,any]=INDEX(%2$s, %1$s)
functions.Translate[any,any]=
functions.Normalize[any]=
functions.Normalize[any,any]=
functions.Normalize[any,any,any]=

#
# Regular expression functions.
# Need to determine if the regular expression flavor is XQuery or POSIX.
#
functions.SubstringRegex[any,any,any,any,any]=
functions.OccurrencesRegex[any,any,any,any]=
functions.PositionRegex[any,any,any,any,any,any]=

#
# Numeric scalar functions.
#
functions.Mod[any,any]=((%1$s) MOD (%2$s))
functions.Power[any,any]=CAST(POWER(%1$s, %2$s) AS DOUBLE PRECISION)
functions.Random[]=CAST(RANDOM(0,999999999) as DOUBLE PRECISION) / 1000000000
functions.Random[any]=
functions.Log10[any]=Log(%1$s)
functions.Round[any]=
functions.Round[any,any]=ROUND(%1$s, %2$s)
functions.Round[any,any,any]=

#
# Array scalar functions.
#
functions.Cardinality[any]=
functions.TrimArray[any,any]=

#
# Trigonometric functions.
#

#
# Datetime value functions.
#
functions.CurrentDate[]=CURRENT_DATE
functions.CurrentTime[]=
functions.CurrentTimestamp[]=
functions.LocalTime[]=CURRENT_TIME
functions.LocalTimestamp[]=CURRENT_TIMESTAMP
functions.CurrentTime[numeric]=
functions.CurrentTimestamp[numeric]=
functions.LocalTime[numeric]=
functions.LocalTimestamp[numeric]=

#
# XML functions.
#
functions.XMLAttributes=
functions.XMLComment=
functions.XMLConcat=
functions.XMLDocument=
functions.XMLElement=
functions.XMLExists=
functions.XMLForest=
functions.XMLParse=
functions.XMLPI=
functions.XMLNamespaces=
functions.XMLQuery=
functions.XMLSerialize=
functions.XMLTable=
functions.XMLText=
functions.XMLTransform=
functions.XMLValidate=

#
# JSON functions.
#
functions.JSONArray=
functions.JSONExists=
functions.JSONObject=
functions.JSONQuery=
functions.JSONTable=
functions.JSONValue=

#
# Business date functions.
#
functions.AddFractionalSeconds[any,any]=
functions.AddSeconds[any,any]=( (%1$s) + cast( (%2$s) as INTERVAL SECOND ) )
functions.AddMinutes[any,any]=( (%1$s) + cast( (%2$s) as INTERVAL MINUTE ) )
functions.AddHours[any,any]=( (%1$s) + cast( (%2$s) as INTERVAL HOUR ) )
functions.AddDays[any,any]=( (%1$s) + cast( (%2$s) as INTERVAL DAY(4) ) )
functions.AddWeeks[any,any]=( (%1$s) + cast( (%2$s * 7) as INTERVAL DAY(4) ) )
functions.AddMonths[any,any]=ADD_MONTHS( %1$s, CAST(%2$s as INTEGER) )
functions.AddMonths[interval_year_month,numeric]=( (%1$s) + cast( (%2$s) as INTERVAL MONTH(4) ) )
functions.AddQuarters[any,any]=ADD_MONTHS( %1$s, (CAST(%2$s as INTEGER) * 3) )
functions.AddQuarters[interval_year_month,numeric]=( (%1$s) + cast( (%2$s * 3) as INTERVAL MONTH(4) ) )
functions.AddYears[any,any]=ADD_MONTHS( %1$s, ( (CAST(%2$s as INTEGER)) * 12 ) )
functions.AddYears[interval_year_month,numeric]=( (%1$s) + cast( (%2$s) as INTERVAL YEAR(4) ) )
functions.FractionalSecondsBetween[any,any]=
functions.SecondsBetween[any,any]=
functions.MinutesBetween[any,any]=
functions.HoursBetween[any,any]=
functions.DaysBetween[date,date]=( (%1$s) - (%2$s) )
functions.DaysBetween[date,timestamp]=( (%1$s) - cast( (%2$s) as DATE ) )
functions.DaysBetween[timestamp,date]=( cast( (%1$s) as DATE ) - (%2$s) )
functions.DaysBetween[any,any]=( cast( (%1$s) as DATE ) - cast( (%2$s) as DATE) )
functions.WeeksBetween[any,any]=
functions.MonthsBetween[any,any]=
functions.QuartersBetween[any,any]=
functions.YearsBetween[any,any]=
functions.Age[any]=
functions.DayOfWeek[any,any]=
functions.DayOfYear[any]=CAST( ( CAST ((%1$s) AS DATE) + 1 -  CAST( ( CAST( EXTRACT( YEAR FROM (CAST ((%1$s) AS DATE) )) AS CHAR(4)) || '-01-01' )  AS DATE) ) AS INTEGER)
functions.DaysToEndOfMonth[any]=(EXTRACT( DAY FROM (ADD_MONTHS((%1$s) - CAST( EXTRACT( DAY FROM (%1$s) ) AS INTERVAL DAY) + INTERVAL '1' DAY, 1) - INTERVAL '1' DAY)) - EXTRACT(DAY FROM (%1$s)))
functions.FirstOfMonth[any]=( (%1$s) - CAST((EXTRACT(DAY FROM (%1$s))-1) AS INTERVAL DAY) )
functions.LastOfMonth[any]=( ADD_MONTHS( (%1$s) - CAST((EXTRACT(DAY FROM (%1$s))-1) AS INTERVAL DAY), 1 ) - INTERVAL '1' DAY )
functions.MakeTimestamp[any,any,any]=
functions.WeekOfYear[any]=
functions.YMDIntBetween[any,any]=

#
# FDS and JDBC functions.
#
#Substring function to negative START value to parse the input string from its rightmost end.
functions.SubstringR[any,any]=CASE WHEN (%2$s) < 0 THEN (SUBSTR( %1$s, (CHAR_LENGTH(%1$s ) - ABS(%2$s) + 1))) ELSE (SUBSTR(%1$s, %2$s)) END
functions.SubstringR[any,any,any]=CASE WHEN (%2$s) < 0 THEN (SUBSTR( %1$s, (CHAR_LENGTH(%1$s ) - ABS(%2$s) + 1), %3$s)) ELSE (SUBSTR(%1$s, %2$s, %3$s)) END
functions.length[text]={fn LENGTH(%1$s)}
functions.locate[text,text]={fn LOCATE(%1$s, %2$s)}
functions.ltrim[text]={fn LTRIM(%1$s)}
functions.ucase[text]={fn UCASE(%1$s)}
functions.year[datetime]={fn YEAR(%1$s)}
functions.month[datetime]={fn MONTH(%1$s)}
functions.concat[any,any]={fn CONCAT(%1$s, %2$s)}
functions.pi[]={fn PI()}
functions.left[text,numeric]=SUBSTR(%1$s, 1, %2$s)
functions.dayofweek[date]=CAST( ( CAST ((%1$s) AS DATE) - CAST( ( '1970-01-01' )  AS DATE) + 5) AS INTEGER) MOD 7
functions.dayofyear[date]=CAST( ( CAST ((%1$s) AS DATE) + 1 -  CAST( ( CAST( EXTRACT( YEAR FROM (CAST ((%1$s) AS DATE) )) AS CHAR(4)) || '-01-01' )  AS DATE) ) AS INTEGER)
functions.monthname[date]=TRIM( SUBSTR ('         January  February March    April    May      June     July      August  SeptemberOctober  November December ', ( CAST ( CAST ( (%1$s) as DATE) as INTEGER)/100 MOD 100)*9 + 1,9))

#
# Temporal functions.
#
functions.dqmudf.begin[period]=BEGIN(%1$s)
functions.dqmudf.contains[period,period]=%1$s CONTAINS %2$s
functions.dqmudf.end[period]=END(%1$s)
functions.dqmudf.intersect[period]=P_INTERSECT(%1$s)
functions.dqmudf.last[period]=LAST(%1$s)
functions.dqmudf.ldiff[period]=LDIFF(%1$s)
functions.dqmudf.meets[period,period]=%1$s MEETS %2$s
functions.dqmudf.next[period]=NEXT(%1$s)
functions.dqmudf.normalize[period,period]=%1$s P_NORMALIZE %2$s
functions.dqmudf.overlaps[period,period]=%1$s OVERLAPS %2$s
functions.dqmudf.precedes[period,period]=%1$s PRECEDES %2$s
functions.dqmudf.prior[period]=PRIOR(%1$s)
functions.dqmudf.rdiff[period]=RDIFF(%1$s)

#
# Literals.
#
literals.binary=false
literals.blob=true
literals.clob=true
literals.boolean=false
literals.date=true
literals.time=true
literals.time_with_time_zone=true
literals.timestamp=true
literals.timestamp_with_time_zone=true
literals.interval_day=true
literals.interval_day_to_hour=true
literals.interval_day_to_minute=true
literals.interval_day_to_second=true
literals.interval_hour=true
literals.interval_hour_to_minute=true
literals.interval_hour_to_second=true
literals.interval_minute=true
literals.interval_minute_to_second=true
literals.interval_second=true
literals.interval_year=true
literals.interval_year_to_month=true
literals.interval_month=true
literals.decimal=true
literals.double=true
literals.float=true
literals.real=true
literals.integer=true
literals.long=true
literals.smallint=true
literals.char=true
literals.nchar=true
literals.nvarchar=true
literals.varchar=true
literals.xml=false


#
# Literal format specifications.
#
literals.format.time=TIME '%1$02d:%2$02d:%3$02d%4$.7s'
literals.format.time_with_time_zone=TIME '%1$02d:%2$02d:%3$02d%4$.7s%7$c%5$02d:%6$02d'
literals.format.timestamp=TIMESTAMP '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.7s'
literals.format.timestamp_with_time_zone=TIMESTAMP '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.7s%10$c%8$02d:%9$02d'
literals.format.interval_day=INTERVAL %3$s'%1$d' DAY
literals.format.interval_day_to_hour=INTERVAL %4$s'%1$d %2$02d' DAY TO HOUR
literals.format.interval_day_to_minute=INTERVAL %5$s'%1$d %2$02d:%3$02d' DAY TO MINUTE
literals.format.interval_day_to_second=INTERVAL %8$s'%1$d %2$02d:%3$02d:%4$02d%5$.7s' DAY TO SECOND
literals.format.interval_hour=INTERVAL %3$s'%1$d' HOUR
literals.format.interval_hour_to_minute=INTERVAL %4$s'%1$d:%2$02d' HOUR TO MINUTE
literals.format.interval_hour_to_second=INTERVAL %7$s'%1$d:%2$02d:%3$02d%4$.7s' HOUR TO SECOND
literals.format.interval_minute=INTERVAL %3$s'%1$d' MINUTE
literals.format.interval_minute_to_second=INTERVAL %6$s'%1$d:%2$02d%3$.7s' MINUTE TO SECOND
literals.format.interval_second=INTERVAL %5$s'%1$02d%2$.7s' SECOND
literals.format.interval_year=INTERVAL %3$s'%1$d' YEAR
literals.format.interval_year_to_month=INTERVAL %4$s'%1$d-%2$02d' YEAR TO MONTH
literals.format.interval_month=INTERVAL %3$s'%1$d' MONTH
literals.format.nchar='%s'
literals.format.nvarchar='%s'

#
# Data types.
#
dataType.nchar=false
dataType.nvarchar=false

#
# Data source type overrides
#
#datasource.type.TIME_WITH_TIME_ZONE=time with time zone
#datasource.type.time_with_time_zone.method=getTimeZoneWithCalendar
#datasource.type.TIMESTAMP_WITH_TIME_ZONE=timestamp with time zone
#datasource.type.timestamp_with_time_zone.method=getTimeZoneWithCalendar
#datasource.type.INTERVAL_YEAR=interval year
#datasource.type.INTERVAL_MONTH=interval month
#datasource.type.INTERVAL_YEAR_TO_MONTH=interval year to month
#datasource.type.INTERVAL_DAY=interval day
#datasource.type.INTERVAL_HOUR=interval hour
#datasource.type.INTERVAL_MINUTE=interval minute
#datasource.type.INTERVAL_SECOND=interval second
#datasource.type.INTERVAL_DAY_TO_HOUR=interval day to hour
#datasource.type.INTERVAL_DAY_TO_MINUTE=interval day to minute
#datasource.type.INTERVAL_DAY_TO_SECOND=interval day to second
#datasource.type.INTERVAL_HOUR_TO_MINUTE=interval hour to minute
#datasource.type.INTERVAL_HOUR_TO_SECOND=interval hour to second
#datasource.type.INTERVAL_MINUTE_TO_SECOND=interval minute to second
#datasource.type.PERIOD[date]=period(date)
#datasource.type.PERIOD[time]=period(time)
#datasource.type.PERIOD[timestamp]=period(timestamp)
#datasource.type.PERIOD[timestamp_with_time_zone]=period(timestamp with time zone)

#
# We are unable to retrieve the collation sequence from teradata but we can still check if the comparison is case sensitive or not
#
collation.sequence.sql=SELECT '', CASE WHEN 'A' = 'a' and 'é' = 'e' THEN 'CI_AI' WHEN 'A' = 'a' and 'é' <> 'e' THEN 'CI_AS' WHEN 'A' <> 'a' and 'é' <> 'e' THEN 'CS_AS' ELSE 'CS_AI' END as COLLATOR_STRENGTH

#
# Window specification
# A list of windows specifications that are supported by the DB
# P = PARTITION BY
# O = ORDER BY
# F = FRAME 
#
# Teradata Defect has been opened "RECEQ85HV"
olap.Window.Specification[O]=false
olap.Window.Specification[PO]=false