analytics/configuration/xqe/hdb.properties

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

# 
# Delimiters
# 
# While a vendor may parse a statement with comments it may strip them out and the server not see them
delimiters.commentBegin=/*
delimiters.commentEnd=*/

#
# Various limits.
#
limits.castClobToVarcharMaxSize=5000

# 
# Keywords
# 
keywords.columnAlias=AS


# 
# General
# 
# 
# Null ordering
# 
# No support is provided for vendors who change how nulls sort based on data type.
general.nullsAreSortedHigh=false
general.nullsAreSortedLow=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
# 
supports.columnAliasing=true
supports.tableCorrelationNames=true
supports.expressionsInOrderBy=true
supports.aliasInOrderByExpression=true
supports.orderByName=true
supports.orderByOrdinal=true
supports.expressionsInINPredicate=true
supports.likeEscapeClause=true
supports.fullOuterJoins=true
supports.outerJoins=true
# Subqueries not supported in Group-by
# Subquery column alias not supported
supports.subqueriesInComparisons=true
supports.subqueriesInExists=true
supports.subqueriesInIns=true
supports.subqueriesInQuantifieds=true
supports.subqueriesInCase=true
supports.correlatedSubqueries=true
supports.scalarSubqueries=true
supports.withClauseInDerivedTable=false
supports.nestedWithClause=false
supports.recursiveWithClause=false
# Currently,  SAP hana returns 1/2 as decimal(34,0) which is same as integer. Therefore, the switch should set to "true"
supports.integerDivision=true
supports.nestedOlap=false
supports.derivedColumnLists=false
# Does not allow grouping on non project column
supports.blobsInGroupBy=false
supports.blobsInOrderBy=false
supports.emptyStringIsNull=true
supports.expressionsInGroupBy=true
supports.constantsInWindows=false
supports.callProcedureInDerivedTable=false
supports.join.subqueriesInOnClause=false
supports.hanaInputParameters=true
#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

# 
# Grouping query optimization
# 
# If the RDBMS has costing/execution issues with group by or distinct consider these transforms
performance.convertGroupByToDistinct=false
performance.convertDistinctToGroupBy=false

# V5 master-detail optimization when allRows optimization is specified
v5.master-detail.transform=false

# 
# Commands
# 
commands.Select=SELECT
commands.Call=CALL

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

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

#
# Constructors - context overrides.
#
constructors.row.between=false
constructors.row.comparison=true
constructors.row.in=true
constructors.row.isDistinctFrom=false
constructors.row.simpleCase=false

# 
# Clauses
# 
clauses.From=FROM
clauses.Where=WHERE
clauses.GroupBy=GROUP BY
clauses.Having=HAVING
clauses.With=WITH
clauses.WithRecursive=
clauses.OrderBy=ORDER BY
clauses.Distinct=DISTINCT
clauses.Top= TOP %1$s
clauses.Top.Position=top.distinct
clauses.At=
clauses.Window=
clauses.TableSampleSystem=
clauses.TableSampleBernoulli=

# 
# Joins
# 
joins.Cross=%1$s CROSS JOIN %2$s
joins.Inner=%1$s INNER JOIN %2$s ON %3$s
joins.LeftOuter=%1$s LEFT OUTER JOIN %2$s ON %3$s
joins.RightOuter=%1$s RIGHT OUTER JOIN %2$s ON %3$s
joins.FullOuter=%1$s FULL OUTER JOIN %2$s ON %3$s

# 
# Set Operators
# 
# One or more set operations does not follow ISO data type combination rules. Can effect set operations, CASE, COALESCE...
operators.set.Union=%1$s UNION %2$s
operators.set.Union.all=%1$s UNION ALL %2$s
operators.set.Intersect=%1$s INTERSECT %2$s
operators.set.Intersect.all= 
operators.set.Except=%1$s EXCEPT %2$s
operators.set.Except.all= 

# 
# Logical Operators
# 
operators.logical.And=%1$s AND %2$s
operators.logical.Or=%1$s OR %2$s
operators.logical.Not=NOT ( %1$s )
operators.logical.Is=
operators.logical.IsNot=

# 
# Arithmetic and Character operators
# 
#SAP HANA connot support date - date
operators.arithmetic.Subtract[date,date]=DAYS_BETWEEN(%2$s, %1$s)
operators.arithmetic.Subtract[date,any]=
operators.arithmetic.Subtract[timestamp,any]=
operators.arithmetic.Subtract[time,any]=
#OSS 0001101325 2012
operators.arithmetic.Divide[integer,integer]=
operators.arithmetic.Divide[integer,smallint]=
operators.arithmetic.Divide[integer,long]=
operators.arithmetic.Divide[smallint,smallint]=
operators.arithmetic.Divide[smallint,integer]=
operators.arithmetic.Divide[smallint,long]=
operators.arithmetic.Divide[long,smallint]=
operators.arithmetic.Divide[long,integer]=
operators.arithmetic.Divide[long,long]=
#String functions return wrong datatype with wrong precision, therefore, turning off some string functions
operators.arithmetic.Concat[char,any]= 
operators.arithmetic.Concat[nchar,any]= 
operators.arithmetic.Concat[any,char]= 
operators.arithmetic.Concat[any,nchar]= 
operators.arithmetic.Concat[blob,any]=
operators.arithmetic.Concat[any,blob]=
operators.arithmetic.Concat[any,any]=%1$s || %2$s


# 
# Grouping Operators
# 
operators.groupBy.Rollup=ROLLUP
operators.groupBy.Cube=CUBE
operators.groupBy.GroupingSets=GROUPING SETS

# 
# Comparison Predicates
# 
predicates.comparison.Equals[clob,any]= 
predicates.comparison.Equals[any,clob]= 
predicates.comparison.Equals[blob,any]= 
predicates.comparison.Equals[any,blob]= 

predicates.comparison.GreaterThan[clob,any]= 
predicates.comparison.GreaterThan[any,clob]= 
predicates.comparison.GreaterThan[blob,any]= 
predicates.comparison.GreaterThan[any,blob]= 

predicates.comparison.GreaterThanOrEquals[clob,any]= 
predicates.comparison.GreaterThanOrEquals[any,clob]= 
predicates.comparison.GreaterThanOrEquals[blob,any]= 
predicates.comparison.GreaterThanOrEquals[any,blob]= 

predicates.comparison.LessThan[clob,any]= 
predicates.comparison.LessThan[any,clob]= 
predicates.comparison.LessThan[blob,any]= 
predicates.comparison.LessThan[any,blob]=

predicates.comparison.LessThanOrEquals[clob,any]= 
predicates.comparison.LessThanOrEquals[any,clob]= 
predicates.comparison.LessThanOrEquals[blob,any]= 
predicates.comparison.LessThanOrEquals[any,blob]=

predicates.comparison.NotEquals[clob,any]= 
predicates.comparison.NotEquals[any,clob]= 
predicates.comparison.NotEquals[blob,any]= 
predicates.comparison.NotEquals[any,blob]=


# 
# Predicates
# 
predicates.In[any,any]=%1$s IN ( %2$s )
predicates.In[clob,any]=
predicates.In[any,clob]=
predicates.Overlaps[any,any,any,any]=
predicates.LikeRegex=
predicates.LikeRegex.flag=
predicates.Similar.escape= 
predicates.Similar=
predicates.Similar.escape=
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)

#
# Period predicates.
#
predicates.PeriodOverlaps[any,any]=
predicates.PeriodEquals[any,any]=
predicates.PeriodContains[any,any]=
predicates.PeriodPrecedes[any,any]=
predicates.PeriodSucceeds[any,any]=
predicates.PeriodImmediatelyPrecedes[any,any]=
predicates.PeriodImmediatelySucceeds[any,any]=

# 
# Conditional expressions
# 
# One or more case operations does not follow ISO type rules.
expressions.SimpleCase=CASE

#expressions.SearchedCase.compatibleResults=false
expressions.Coalesce=COALESCE(%1$s)
expressions.NullIf=NULLIF(%1$s, %2$s)

# 
# Cast
# 
# OSS: 0000491475 2012
expressions.Cast[any,float]=TO_REAL(%1$s)

#OSS: 0000491530 2012
#SQL standard page 213 using  respective values in an execution of CURRENT_DATE
expressions.Cast[time,timestamp]=TO_TIMESTAMP(CONCAT(CONCAT(current_date,' '), %1$s) )
expressions.Cast[date,timestamp]=TO_TIMESTAMP(%1$s,'YYYY-MM-DD')
# turn off cast to char/nchar, because it return varchar/nvarchar, when concat for date+time generated from transfermation ConvertDatePlusTimeToCompatibleSQL, it will be failed
# failed testcase testConvertDatePlusTimeToCompatibleSQL
expressions.Cast[any,nchar]=
expressions.Cast[any,char]=
expressions.Cast[xml,any]=
expressions.Cast[clob,any]=
expressions.Cast[any,xml]=
expressions.Cast[decimal,nvarchar]=
expressions.Cast[decimal,varchar]=

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

# 
# Extract
# 
expressions.Extract.YEAR[any]=EXTRACT(YEAR FROM %1$s)
expressions.Extract.MONTH[any]=EXTRACT(MONTH FROM %1$s)
expressions.Extract.DAY[any]=EXTRACT(DAY FROM %1$s)
expressions.Extract.HOUR[any]=EXTRACT(HOUR FROM %1$s)
expressions.Extract.MINUTE[any]=EXTRACT(MINUTE FROM %1$s)
#OSS: 0001070313 2012
#SAP HANA return decimal(34,0) and our RQE regard it as integer and automatically round it or cast it to integer.
expressions.Extract.SECOND[timestamp]=TO_DECIMAL(EXTRACT(SECOND FROM %1$s),11,9)
expressions.Extract.SECOND[any]=EXTRACT(SECOND FROM %1$s)
expressions.Extract.TIMEZONE_HOUR[any]=
expressions.Extract.TIMEZONE_MINUTE[any]=
expressions.Extract.EPOCH[any]=

# 
# Trim
# 
#functional support; 
expressions.Trim.BOTH[char]=
expressions.Trim.LEADING[char]=
expressions.Trim.TRAILING[char]=
expressions.Trim.BOTH[any,char]=
expressions.Trim.LEADING[any,char]=
expressions.Trim.TRAILING[any,char]=
xpressions.Trim.BOTH[nchar]=
expressions.Trim.LEADING[nchar]=
expressions.Trim.TRAILING[nchar]=
expressions.Trim.BOTH[any,nchar]=
expressions.Trim.LEADING[any,nchar]=
expressions.Trim.TRAILING[any,nchar]=
expressions.Trim.BOTH[blob]=
expressions.Trim.LEADING[blob]=
expressions.Trim.TRAILING[blob]=
expressions.Trim.BOTH[any,blob]=
expressions.Trim.LEADING[any,blob]=
expressions.Trim.TRAILING[any,blob]=
expressions.Trim.BOTH[any]=TRIM(%1$s)
expressions.Trim.LEADING[any]=LTRIM(%1$s)
expressions.Trim.TRAILING[any]=RTRIM(%1$s)
expressions.Trim.BOTH[any,any]=RTRIM(LTRIM(%2$s,%1$s),%1$s)
expressions.Trim.LEADING[any,any]=LTRIM(%2$s,%1$s)
expressions.Trim.TRAILING[any,any]=RTRIM(%2$s,%1$s)


# 
# Window clause
# 

# Lack of window ordering impacts many aggregates being pushed
# Unable to specify a literal in window ordering
# Unable to specify ordering in a window
general.nullsOrderingInWindowSpecification=true

# 
# Window specification
# 
olap.Window.Specification[POF]=false
olap.Window.Specification[PF]=false
olap.Window.Specification[OF]=true
olap.Window.Specification[PO]=true
olap.Window.Specification[P]=true
olap.Window.Specification[O]=true
olap.Window.Specification[F]=false
olap.Window.Specification[]=true

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

# 
# Aggregates
# 
# OSS 0000481944 AVG returns precsion=34 SCALE=0. Cast the result to double.
aggregates.Avg[any]=CAST(AVG(%1$s) as DOUBLE)
aggregates.Max[blob]= 
aggregates.Max[any]=MAX(%1$s)
aggregates.Min[blob]= 
aggregates.Min[any]=MIN(%1$s)
aggregates.Count[any]=COUNT(%1$s)
aggregates.Count[clob]=sum( case when %1$s is not null then 1 else 0 end)
aggregates.Count[blob]=sum( case when %1$s is not null then 1 else 0 end) 
aggregates.CountStar[]=COUNT(*)
aggregates.Sum[any]=SUM(%1$s)
aggregates.StdDevPop[any]=
aggregates.StdDevSamp[any]=STDDEV(%1$s)
aggregates.VarPop[any]=
aggregates.VarSamp[any]=VAR(%1$s)
aggregates.Grouping[any]=
aggregates.XMLAgg[any]=
aggregates.Rank[any,any]=
aggregates.DenseRank[any,any]=
aggregates.PercentRank[any,any]=
aggregates.CumeDistH[any,any]=
aggregates.PercentileCont[any,any]=
aggregates.PercentileDisc[any,any]=
aggregates.ArrayAgg[any]=
aggregates.ArrayAgg[any,any]=
aggregates.Collect[any]=
aggregates.Median[any]=
aggregates.ApproxCountDistinct[any]=

# 
# Distinct aggregates
# 
aggregates.Avg.distinct[any]=
aggregates.Count.distinct[blob]=

# 
# Linear regression aggregates
# 
aggregates.Corr[any,any]=
aggregates.CovarPop[any,any]=
aggregates.CovarSamp[any,any]=
aggregates.RegrAvgX[any,any]=
aggregates.RegrAvgY[any,any]=
aggregates.RegrCount[any,any]=
aggregates.RegrIntercept[any,any]=
aggregates.RegrR2[any,any]=
aggregates.RegrSlope[any,any]=
aggregates.RegrSXX[any,any]=
aggregates.RegrSXY[any,any]=
aggregates.RegrSYY[any,any]=

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

# 
# Character scalar functions
#
functions.CharLength[any]=LENGTH(%1$s)
functions.BitLength[any]=
functions.OctetLength[any]=
#String functions return wrong datatype with wrong precision, therefore, turning off some string functions
# Hana 2 is returning correct precisions but return char as varchar and nchar as nvarchar
functions.Upper[char]= 
functions.Upper[nchar]= 
functions.Upper[blob]=

#String functions return wrong datatype with wrong precision, therefore, turning off some string functions
# Hana 2 is returning correct precisions but return char as varchar and nchar as nvarchar
functions.Lower[char]= 
functions.Lower[nchar]= 
functions.Lower[blob]=

#String functions return wrong datatype with wrong precision, therefore, turning off some string functions 
functions.Substring[any,any]=SUBSTRING(%1$s,%2$s)
functions.Substring[any,any,any]=SUBSTRING(%1$s, %2$s, %3$s)

#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 (SUBSTRING( %1$s, (LENGTH(%1$s ) - ABS(%2$s) + 1))) ELSE (SUBSTRING(%1$s, %2$s)) END
functions.SubstringR[any,any,any]=CASE WHEN (%2$s) < 0 THEN (SUBSTRING( %1$s, (LENGTH(%1$s ) - ABS(%2$s) + 1), %3$s)) ELSE (SUBSTRING(%1$s, %2$s, %3$s)) END

functions.Position[any,any]= LOCATE(%2$s,%1$s )

functions.Index[blob,any]= 
functions.Index[any,blob]= 
functions.Index[any,any]= LOCATE(%1$s ,%2$s)
functions.Ascii[any]=
functions.Translate[any,any]=
functions.Normalize[any]=
functions.Normalize[any,any]=
functions.Normalize[any,any,any]=

#
# Regular expression functions.
#
functions.SubstringRegex[any,any,any,any,any]=SUBSTR_REGEXPR(%1$s@5[ FLAG %5$s] IN %2$s@3[ FROM %3$s]@4[ OCCURRENCE %4$s])
functions.OccurrencesRegex[any,any,any,any]=OCCURRENCES_REGEXPR(%1$s@4[ FLAG %4$s] IN %2$s@3[ FROM %3$s])
functions.PositionRegex[any,any,any,any,any,any]=LOCATE_REGEXPR(@1[%1$s ]%2$s@6[ FLAG %6$s] IN %3$s@4[ FROM %4$s]@5[ OCCURRENCE %5$s])

# 
# Numeric scalar functions
# 
functions.Abs[interval_day_time]=
functions.Abs[interval_year_month]=
functions.Ceiling[any]=CEIL(%1$s)
#EXP returns double without decimal(34,0) issue
functions.Exp[any]=EXP(%1$s)
# OSS 0000481944 return precsion=34
functions.Floor[decimal]=
functions.Floor[any]=FLOOR(%1$s)
functions.Ln[any]=LN(%1$s)
functions.Log10[any]= LOG(10,%1$s)
# Mod failed exception cases
# OSS 0000481944 return precsion=34 
functions.Mod[decimal,any]=
functions.Mod[any,any]=MOD(%1$s, %2$s)
functions.Sign[any]=SIGN(%1$s)
#Sqrt returns double without decimal(34,0) issue
functions.Sqrt[any]=SQRT(%1$s)
functions.WidthBucket[any,any,any,any]=
#power returns double without decimal(34,0) issue
functions.Power[any,any]=POWER(%1$s, %2$s)
functions.Random[]=RAND()
functions.Random[any]=
functions.Round[any]=ROUND(%1$s)

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


# OSS 0000481944 return precsion=34 without scaler
functions.Round[decimal,any]=
functions.Round[any,any]=ROUND(%1$s, %2$s)
functions.Round[any,any,any]=

# 
# Trig Functions
# 


#
# Windowed aggregates (SQL/OLAP).
#
olap.Max[any]=MAX(%1$s)
olap.Max[blob]=
olap.Min[any]=MIN(%1$s)
olap.Min[blob]=
olap.Sum[any]=SUM(%1$s)
olap.Avg[any]=
olap.Count[any]=COUNT(%1$s)
olap.Count[blob]=
olap.CountStar[]=COUNT(*)
olap.StdDevSamp[any]=
olap.StdDevPop[any]=
olap.VarSamp[any]=
olap.VarPop[any]=
olap.Rank[]=RANK()
olap.DenseRank[]=DENSE_RANK()
olap.PercentRank[]=PERCENT_RANK()
olap.CumeDist[]=CUME_DIST()
olap.PercentileCont[any,any]=
olap.PercentileDisc[any,any]=
olap.Median[any]=
olap.RowNumber[]=ROW_NUMBER()
olap.FirstValue[any]=FIRST_VALUE(%1$s)
olap.LastValue[any]=LAST_VALUE(%1$s)
olap.NTile[any]=NTILE(%1$s)
olap.Tertile[]=
olap.RatioToReport[any]=
olap.Difference[any]=
olap.Lag[any]=LAG(%1$s)
olap.Lag[any,any]=LAG(%1$s, %2$s)
olap.Lag[any,any,any]=LAG(%1$s, %2$s, %3$s)
olap.Lag[any,any,any,any]=
olap.Lag[blob]=
olap.Lag[blob,any]=
olap.Lag[blob,any,any]=
olap.Lead[any]=LEAD(%1$s)
olap.Lead[any,any]=LEAD(%1$s, %2$s)
olap.Lead[any,any,any]=LEAD(%1$s, %2$s, %3$s)
olap.Lead[any,any,any,any]=
olap.Lead[blob]=
olap.Lead[blob,any]=
olap.Lead[blob,any,any]=
olap.NthValue[any,any]=
olap.NthValue[any,any,any]=
olap.NthValue[any,any,any,any]=
olap.Collect[any]=


# 
# Temporal value expressions
# 
# Note: JDBC does not define fractional seconds for TIME data type.
functions.CurrentDate[]=CURRENT_DATE
functions.CurrentTime[]=
functions.CurrentTime[numeric]=
functions.CurrentTimestamp[]=
functions.CurrentTimestamp[numeric]= 
functions.LocalTime[]=CURRENT_TIME 
functions.LocalTimestamp[]=CURRENT_TIMESTAMP
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 functions.
# 
functions.AddFractionalSeconds[any,any]=
functions.AddSeconds[time,any]=
functions.AddSeconds[any,any]=add_seconds(%1$s,%2$s)
functions.AddMinutes[time,any]=
functions.AddMinutes[any,any]=add_seconds(%1$s,floor(%2$s) * 60)
functions.AddHours[time,any]=
functions.AddHours[any,any]=add_seconds(%1$s,floor(%2$s) * 3600)
functions.AddDays[timestamp,any]=(add_days(%1$s, FLOOR(%2$s)))
functions.AddDays[date,any]=(add_days(%1$s, FLOOR(%2$s)))
functions.AddDays[any,any]=
functions.AddWeeks[timestamp,any]=(add_days(%1$s, FLOOR(%2$s * 7)))
functions.AddWeeks[date,any]=(add_days(%1$s, FLOOR(%2$s * 7)))
functions.AddWeeks[any,any]=
functions.AddMonths[timestamp,any]=(add_months(%1$s, FLOOR(%2$s)))
functions.AddMonths[date,any]=(add_months(%1$s , floor(%2$s)))
functions.AddMonths[any,any]=
functions.AddQuarters[timestamp,any]=(add_months(%1$s, FLOOR(%2$s * 3)))
functions.AddQuarters[date,any]=(add_months(%1$s , floor(%2$s * 3)))
functions.AddQuarters[any,any]=
functions.AddYears[timestamp,any]=(add_years(%1$s , floor(%2$s)))
functions.AddYears[date,any]=(add_years(%1$s , floor(%2$s)))
functions.AddYears[any,any]=
functions.FractionalSecondsBetween[any,any]=
functions.SecondsBetween[any,any]=
functions.SecondsBetween[date,date]=SECONDS_BETWEEN(%1$s,%2$s)
functions.MinutesBetween[any,any]=
functions.HoursBetween[any,any]=
functions.DaysBetween[timestamp,timestamp]=DAYS_BETWEEN(TO_DATE(%2$s),TO_DATE(%1$s))
functions.DaysBetween[date,timestamp]=DAYS_BETWEEN(TO_DATE(%2$s),%1$s)
functions.DaysBetween[timestamp,date]=DAYS_BETWEEN(%2$s,TO_DATE(%1$s))
functions.DaysBetween[date,date]=DAYS_BETWEEN(%2$s,%1$s)
functions.DaysBetween[any,any]=
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[date]=DAYOFYEAR(%1$s) 
functions.DayOfYear[timestamp]=DAYOFYEAR(%1$s) 
functions.DayOfYear[any]=
functions.DaysToEndOfMonth[date]=DAYS_BETWEEN(%1$s,LAST_DAY(%1$s))
functions.DaysToEndOfMonth[any]=
functions.FirstOfMonth[any]=add_days(%1$s, -dayofmonth(%1$s)+1)
functions.LastOfMonth[timestamp]=CONCAT(CONCAT(LAST_DAY(%1$s),' '), TO_TIME(%1$s))
functions.LastOfMonth[any]=LAST_DAY(%1$s)
functions.MakeTimestamp[any,any,any]=TO_TIMESTAMP( ( LPAD( %1$d, 4, '0' ) || '-' || LPAD( %2$d, 2, '0' ) || '-' || LPAD( %3$d, 2, '0' ) ), 'YYYY-MM-DD' )
functions.YMDIntBetween[any,any]=
functions.WeekOfYear[date]=TO_INT(SUBSTRING(ISOWEEK(%1$s),7,2))
functions.WeekOfYear[timestamp]=TO_INT(SUBSTRING(ISOWEEK(%1$s),7,2))
functions.WeekOfYear[time]=TO_INT(SUBSTRING(ISOWEEK(CURRENT_DATE),7,2))
functions.WeekOfYear[any]=


# Multiple 'vendor' mappings were found first found is active. Select the preferred entry and delete the others.
# functions.AddDays[any,any]=(add_days(%1s, FLOOR(%2s)))
# functions.AddMonths[timestamp,any]=(add_months(%1s, FLOOR(%2s)))
# functions.AddMonths[date,double]=(add_months(%1s , floor(%2s)))
# functions.AddMonths[date,decimal]=(add_months(%1s, FLOOR(%2s)))
# functions.AddMonths[date,smallint]=(add_months(%1s , floor(%2s)))
# functions.AddMonths[date,long]=(add_months(%1s , floor(%2s)))
# functions.AddMonths[date,float]=(add_months(%1s, FLOOR(%2s)))
# functions.AddMonths[date,integer]=(add_months(%1s , floor(%2s)))
# functions.AddYears[timestamp,decimal]=(add_months(%1s , floor(%2s) * 12))
# functions.AddYears[timestamp,double]=(add_months(%1s , floor(%2s) * 12))
# functions.AddYears[timestamp,smallint]=(add_months(%1s , floor(%2s) * 12))
# functions.AddYears[timestamp,long]=(add_months(%1s , floor(%2s) * 12))
# functions.AddYears[timestamp,float]=(add_years(%1s, FLOOR(%2s)))
# functions.AddYears[timestamp,integer]=(add_months(%1s , floor(%2s) * 12))
# functions.AddYears[date,double]=(add_months(%1s , floor(%2s) * 12))
# functions.AddYears[date,decimal]=(add_years(%1s, FLOOR(%2s)))
# functions.AddYears[date,smallint]=(add_months(%1s , floor(%2s) * 12))
# functions.AddYears[date,long]=(add_months(%1s , floor(%2s) * 12))
# functions.AddYears[date,float]=(add_years(%1s, FLOOR(%2s)))
# functions.AddYears[date,integer]=(add_months(%1s , floor(%2s) * 12))
# functions.FirstOfMonth[any,any]=(add_days(add_days(%1s, - dayofmonth(%1s)),1))
# functions.LastOfMonth[any,any]=(add_days(add_days(%1s, - dayofmonth(%1s)),1))
# functions.MakeTimestamp[any,any,any]=cast(TO_TIMESTAMP('%1s-%2s-%3s','YYYY-MM-DD') as timestamp)
# functions.AddHours[any,any]=add_seconds(%1s,floor(%2s) * 3600)
# functions.AddMinutes[any,any]=add_seconds(%1s,floor(%2s) * 60)
# functions.AddSeconds[any,any]=add_seconds(%1s,floor(%2s))

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

# Literal format specifications. Formats are compatible with String.format().
# Values for default behaviour are listed.
# Only char, temporal and string types can be overridden.
# Fractional seconds are presented as a string of up to 10 characters: '.' followed by 9 character
# 0-padded string representing nanoseconds or empty.
literals.format.boolean=TRUE:FALSE:UNKNOWN
literals.format.char='%s'
literals.format.clob='%s'
#cannot use this date format, because when running add_days(DATE '2000-12-31', 1), SAP HANA throws Error: SAP DBTech JDBC: [266] (at 7): inconsistent datatype: line 1 col 8 (at pos 7)
#SQLState:  07006
#ErrorCode: 266
#DATE '%1$04d-%2$02d-%3$02d'
literals.format.date=TO_DATE('%1$04d-%2$02d-%3$02d','YYYY-MM-DD')
literals.format.interval_day=
literals.format.interval_day_to_hour=
literals.format.interval_day_to_minute=
literals.format.interval_day_to_second=
literals.format.interval_hour=
literals.format.interval_hour_to_minute=
literals.format.interval_hour_to_second=
literals.format.interval_minute=
literals.format.interval_minute_to_second=
literals.format.interval_month=
literals.format.interval_second=
literals.format.interval_year=
literals.format.interval_year_to_month=
literals.format.nchar=TO_NCHAR('%s')
literals.format.nvarchar=TO_NVARCHAR('%s')
literals.format.time=TO_TIME('%1$02d:%2$02d:%3$02d','HH:MI:SS')
literals.format.time_with_time_zone=
literals.format.timestamp=TO_TIMESTAMP('%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.4s')
literals.format.timestamp_with_time_zone=
literals.format.varchar='%s'
literals.format.double=TO_DOUBLE('%s')
# 
# DataTypes
# 
dataType.smallint=true
dataType.integer=true
dataType.long=true
dataType.decimal=true
dataType.float=true
dataType.double=true
dataType.char=false
dataType.nchar=false
dataType.varchar=true
dataType.nvarchar=true
dataType.clob=true
dataType.blob=true
dataType.date=true
dataType.time=true
dataType.time_with_time_zone=false
dataType.timestamp=true
dataType.timestamp_with_time_zone=false
dataType.interval_year=false
dataType.interval_month=false
dataType.interval_year_to_month=false
dataType.interval_day=false
dataType.interval_hour=false
dataType.interval_minute=false
dataType.interval_second=false
dataType.interval_day_to_hour=false
dataType.interval_day_to_minute=false
dataType.interval_day_to_second=false
dataType.interval_hour_to_minute=false
dataType.interval_hour_to_second=false
dataType.interval_minute_to_second=false
dataType.boolean=false
dataType.binary=false
dataType.xml=true
dataType.period=false

# 
# Collation
# 
# Collation Sequence SQL (SQL statement for retrieving the collation sequence)
# This statement returns a single row and single column containing the collation sequence
collation.sequence.sql=
# Datbase Encoding SQL. This statement retrieves the charset name for the non-unicode character data.
# This statement returns a single row and single column with the charset name for use in a java.nio.CharsetEncoder.
database.charset.sql=

# 
# dataType.comparable
# 
# Used to indicate that some data types that are comparable locally may not by the database
# e.g. dataType.comparable[varchar,nvarchar]=false

# 
# dataType.promotion
# 
# Used to indicate what direction the promotion needs to occur
# <lhs> -> <rhs> these properties are not symetrical
# e.g. dataType.promotion[char,nvarchar]=true