analytics/configuration/xqe/flint.properties

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


# 
# Delimiters
# 
delimiters.commentBegin=
delimiters.commentEnd=
delimiters.columnDelimiter=`
# delimiters.catalogDelimiter=
# delimiters.schemaDelimiter=
# delimiters.tableDelimiter=
delimiters.identifierQuoteString=`
# delimiters.searchStringEscape=
# delimiters.catalogSeparator=
delimiters.literalQuoteEscape=\\'

# 
# Limits
# 
# Normally these values would be derived from the JDBC driver DatabaseMetadata
# limits.maxBinaryLiteralLength=
# limits.maxCharLiteralLength=
# limits.maxColumnNameLength=
# limits.maxColumnsInGroupBy=
# limits.maxColumnsInIndex=
# limits.maxColumnsInOrderBy=
# limits.maxColumnsInSelect=
# limits.maxColumnsInTable=
# limits.maxConnections=
# limits.maxCursorNameLength=
# limits.maxIndexLength=
# limits.maxSchemaNameLength=
# limits.maxProcedureNameLength=
# limits.maxCatalogNameLength=
# limits.maxRowSize=
# limits.maxStatementLength=
# limits.maxStatements=
limits.maxStatements=1
# limits.maxTableNameLength=
# limits.maxTablesInSelect=
# limits.maxUserNameLength=
limits.defaultTransactionIsolation=
# limits.maxLengthInClause

# 
# Keywords
# 
keywords.columnAlias=AS

# 
# General
# 
# 
# Null ordering
# 
general.nullsAreSortedHigh=false
general.nullsAreSortedLow=false
general.nullsAreSortedAtStart=false
general.nullsAreSortedAtEnd=false
general.nullsOrdering=true
general.nullsOrderingInWindowSpecification=false

# Cursor options - appended to end of generated SELECT statement.
general.cursorOptions=

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

# 
# Various
# 
supports.duplicateColumnsInSelectList=true
supports.columnAliasing=true
supports.tableCorrelationNames=true
supports.expressionsInSelectList=true
supports.expressionsInINPredicate=true
supports.expressionsInOrderBy=true
supports.booleanExpressionsInSelectList=true
supports.fieldsOfComplexTypeInSelectList=false
supports.nestedOlap=false
supports.orderByAlias=true
supports.orderByName=true
supports.orderByOrdinal=true
supports.blobsInGroupBy=false
supports.blobsInOrderBy=false
# Results for other scalar, aggregate and set operations will differ from DQM/ISO-SQL.
supports.emptyStringIsNull=false
supports.crossProducts=true
supports.multipleDistinctAggregates=true
supports.rowNumberNoOrderBy=false
supports.expressionsInSelectList=true
supports.likeEscapeClause=true
supports.expressionsInLikePattern=true
supports.outerJoins=true
supports.fullOuterJoins=true
supports.withClauseInDerivedTable=false
supports.derivedColumnLists=false
supports.expressionsInINPredicate=true
# Subqueries not supported in Having
# Subqueries not supported in Group-by
# Subquery column alias not supported
supports.subqueriesInComparisons=true
supports.subqueriesInExists=true
supports.subqueriesInIns=true
supports.subqueriesInQuantifieds=false
supports.subqueriesInOnClause=false
supports.subqueriesInCase=false
supports.correlatedSubqueries=false
supports.correlatedSubqueriesInSelectList=false
supports.correlatedSubqueriesInIns=false
supports.scalarSubqueries=false
supports.nestedWithClause=false
# integerDivision switched back to 'true' in order to be consistent with local processing.
supports.integerDivision=true
supports.expressionsInGroupBy=true
supports.expressionsInOrderBy=true
supports.aliasInOrderByExpression=false
supports.orderByUnrelated=true
supports.groupByUnrelated=false
supports.thetaJoins=true
supports.equiJoins=true
supports.recursiveWithClause=false
supports.orderByInDerivedTable=true
supports.callProcedureInDerivedTable=false
supports.constantsInWindows=true
#join condition
supports.join.betweenInOnClause=true
supports.join.inPredicateInOnClause=true
supports.join.isNullInOnClause=true
supports.join.likeInOnClause=true
supports.join.notInOnClause=true
supports.join.orInOnClause=true
supports.join.subqueriesInOnClause=true
supports.join.onlyEquiWithAnd=false
supports.join.inner.limitedThetaJoins=false
supports.join.outer.thetaJoins=true
supports.join.full.thetaJoins=true
supports.join.full.distinctJoins=true
supports.rewriteImplicitCrossJoins=true
supports.constantsInCount=true
supports.hanaInputParameters=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


# 
# 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
performance.convertHavingToWhere=false
performance.transitiveClosure=false
performance.predicatePushdown=false
performance.semiJoin=false

# RTC 377496
# Set this entry to F to avoid generation of predicates of the form
# T1.C1 = T2.C1 OR ( T1.C1 IS NULL AND T2.C1 IS NULL ). Care must be
# taken, however, since doing so may cause data integrity problems if
# data contains null values.
performance.generateEqualOrNull=true

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

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

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

# 
# Constructors - context overrides.
# 
constructors.row.simpleCase=false
constructors.row.between=false
constructors.row.isDistinctFrom=false
constructors.row.inListToTable=false

# 
# Clauses
# 
clauses.From=FROM
clauses.Where=WHERE
clauses.GroupBy=GROUP BY
clauses.Having=HAVING
# Does not allow column list in common table expression
# Recursive form of common table expression not supported
clauses.WithRecursive=
clauses.With=WITH
clauses.OrderBy=ORDER BY
clauses.Distinct=DISTINCT
clauses.Top=LIMIT %1$s 
clauses.At=
clauses.Window= 
clauses.TableSampleSystem=TABLESAMPLE (%1$s PERCENT)
clauses.TableSampleBernoulli=TABLESAMPLE (%1$s PERCENT)
clauses.TableSampleBeforeAlias=true
clauses.ForSystemTimeAsOf=
clauses.ForSystemTimeFrom=
clauses.ForSystemTimeBetween=

# 
# Joins
# 
# Does not allow on condition to use set functions
# Does not allow join conditions to use sub-queries
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
joins.RightNested=%1$s

# Bracket inner join groups in order to avoid parsing error
# A LOJ
#  B INNER JOIN C ON B.x = C.x
# ON A.x = B.x
# is converted to:
# A LOJ
#    (B INNER JOIN C ON B.x = C.x)
# ON A.x = B.x
#
joins.BracketInner=true

# 
# Set Operators
# 
operators.set.Union=%1$s UNION DISTINCT %2$s
operators.set.Union.all=%1$s UNION ALL %2$s
operators.set.Intersect=%1$s INTERSECT DISTINCT %2$s
operators.set.Intersect.all= 
operators.set.Except=%1$s EXCEPT DISTINCT %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=
operators.logical.IsJson=
operators.logical.IsNotJson=


# 
# Arithmetic and Character operators
# 
# SPARK APACHE JIRA HIVE-9537
operators.arithmetic.Concat[char,any]=
operators.arithmetic.Concat[any,char]=
operators.arithmetic.Concat[any,any]=concat(%1$s, %2$s)
operators.arithmetic.Add[timestamp,any]=
operators.arithmetic.Add[any,timestamp]=
operators.arithmetic.Add[date,any]=
operators.arithmetic.Add[any,date]=
operators.arithmetic.Add[time,any]=
operators.arithmetic.Add[any,time]=
operators.arithmetic.Subtract[date,any]= 
operators.arithmetic.Subtract[any,date]= 
operators.arithmetic.Subtract[date,date]=datediff(%1$s, %2$s)
operators.arithmetic.Subtract[timestamp,any]= 
operators.arithmetic.Subtract[any,timestamp]=
operators.arithmetic.Subtract[time,any]=
operators.arithmetic.Subtract[any,time]=
operators.arithmetic.UnaryPlus[any]=+%1$s
operators.arithmetic.Negate[any]=-%1$s

# 
# Grouping Operators
# 

# some cases where SPARK SQL does not support grouping set scenarios other SQL engines support
operators.groupBy.Rollup=
operators.groupBy.Cube=
operators.groupBy.GroupingSets=

# 
# Comparison Predicates
# 
predicates.comparison.Equals[any,any]=%1$s = %2$s
predicates.comparison.GreaterThan[any,any]=%1$s > %2$s
predicates.comparison.GreaterThanOrEquals[any,any]=%1$s >= %2$s
predicates.comparison.LessThan[any,any]=%1$s < %2$s
predicates.comparison.LessThanOrEquals[any,any]=%1$s <= %2$s
predicates.comparison.NotEquals[any,any]=%1$s <> %2$s


# 
# Predicates
# 
predicates.Between[any,any,any]=%1$s BETWEEN %2$s AND %3$s
predicates.In[any,any]=%1$s IN ( %2$s )
predicates.Overlaps[any,any,any,any]= 
# Does not support value expression in Is Null
predicates.IsNull[any]=%1$s IS NULL
predicates.IsNotNull[any]=%1$s IS NOT NULL
predicates.Like=%1$s LIKE %2$s
predicates.Like.escape=%1$s LIKE %2$s ESCAPE %3$s 
predicates.LikeRegex=
predicates.LikeRegex.flag=
predicates.Similar= 
predicates.Similar.escape= 
predicates.Exists= 
predicates.All= 
predicates.Any= 
predicates.Some= 
predicates.IsDistinctFrom[any,any]=NOT (%1$s <=> %2$s)
predicates.IsNotDistinctFrom[any,any]=%1$s <=> %2$s

#
# 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]=

# 
# Expressions
# 
expressions.ArrayElementRef.zeroBased=false

# 
# Conditional expressions
# 
expressions.SimpleCase=CASE
expressions.SearchedCase=CASE
expressions.Coalesce[any,any]=COALESCE(%1$s)
# Due to how Hive compares varchar and char it will think that a zero length string and space are not equivalent
# APACHE JIRA HIVE-9537, HIVE-3745 and HIVE-9745
#expressions.NullIf=CASE WHEN %1$s = %2$s THEN NULL ELSE %1$s END
expressions.NullIf[any,any]=NULLIF(%1$s, %2$s)

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

# 
# Cast
# 
expressions.Cast[any,any]=CAST(%1$s AS %2$s)
expressions.Cast[any,double]=CAST(%1$s AS double)
expressions.Cast[float,text]=
expressions.Cast[double,text]=
# Allow casting decimal values as varchar to prevent decomposition of binning queries.
expressions.Cast[decimal,varchar]=CAST(%1$s AS %2$s)
expressions.Cast[decimal,text]=
# does not preserve trailing spaces of fixed length characters
expressions.Cast[any,char]=
# Spark does not have time data type, use timestamp
expressions.Cast[any,time]=CAST(%1$s AS timestamp)

# 
# Extract
# 
expressions.Extract.YEAR[any]=year(%1$s)
expressions.Extract.MONTH[any]=month(%1$s)
expressions.Extract.DAY[any]=day(%1$s)
expressions.Extract.HOUR[any]=hour(%1$s)
expressions.Extract.MINUTE[any]=minute(%1$s)
expressions.Extract.SECOND[any]=second(%1$s) + cast(%1$s as double) - cast(cast(from_unixtime(unix_timestamp(%1$s)) as timestamp) as double)
# Flint always stores time in UTC
expressions.Extract.TIMEZONE_HOUR[any]=
expressions.Extract.TIMEZONE_MINUTE[any]=
expressions.Extract.EPOCH[any]=
# 
# Trim
# 
expressions.Trim.BOTH[any]=trim(%1$s)
expressions.Trim.BOTH[any,any]=trim(%1$s, %2$s)
expressions.Trim.LEADING[any]=ltrim(%1$s)
expressions.Trim.LEADING[any,any]=ltrim(%1$s, %2$s)
expressions.Trim.TRAILING[any]=rtrim(%1$s)
expressions.Trim.TRAILING[any,any]=rtrim(%1$s, %2$s)

# 
# Windowed aggregates (SQL/OLAP).
# 
olap.Count[any]=COUNT(%1$s)
olap.CountStar[]=COUNT(*)
olap.Max[any]=MAX(%1$s)
olap.Min[any]=MIN(%1$s)
olap.Sum[any]=SUM(%1$s)
olap.Avg[any]=AVG(%1$s)
olap.StdDevPop[any]= 
olap.StdDevSamp[any]= 
olap.VarPop[any]= 
olap.VarSamp[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.RatioToReport[any]=
olap.RowNumber[]=ROW_NUMBER()
olap.Difference[any]=
olap.FirstValue[any]=FIRST_VALUE(%1$s)
olap.LastValue[any]=LAST_VALUE(%1$s)
# Olap Ntile without an order by will sort nulls first and not last.
olap.NTile[any]=
olap.Tertile[]=
# Olap lag did not throw expected exceptions
olap.Lag[any]=LAG(%1$s)
olap.Lag[any,any]=LAG(%1$s, %2$s)
olap.Lag[any,any,any]=
olap.Lag[any,any,any,any]=
olap.Lead[any]=LEAD(%1$s)
olap.Lead[any,any]=LEAD(%1$s, %2$s)
olap.Lead[any,any,any]=
olap.Lead[any,any,any,any]=
olap.NthValue[any,any]=
olap.NthValue[any,any,any]=
olap.NthValue[any,any,any,any]=
olap.Collect[any]= 

# 
# Window clause
# 
# Olap functions cannot be used in Subquery but no method to disable it.
olap.Window= 
olap.PartitionBy=PARTITION BY %1$s
olap.OrderBy=ORDER BY %1$s

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

# 
# Olap Distinct
# 

# Apache SPARK does only supports MIN/MAX scenarios
olap.Min.distinct[any]=MIN(DISTINCT %1$s)
olap.Max.distinct[any]=MAX(DISTINCT %1$s)
olap.Sum.distinct[any]= 
olap.Avg.distinct[any]= 
olap.Count.distinct[any]= 

# 
# Aggregates
# 
aggregates.Max[any]=MAX(%1$s)
aggregates.Min[any]=MIN(%1$s) 
aggregates.Count[any]=COUNT(%1$s)
aggregates.CountStar[]=COUNT(*)
aggregates.Sum[any]=SUM(%1$s)
aggregates.Avg[any]=AVG(%1$s)
aggregates.StdDevPop[any]=STDDEV_POP(%1$s)
aggregates.StdDevSamp[any]=STDDEV_SAMP(%1$s)
aggregates.VarPop[any]=VAR_POP(%1$s)
aggregates.VarSamp[any]=VAR_SAMP(%1$s)
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.Median[any]=
aggregates.Grouping[any]=
aggregates.XMLAgg=
# Cannot have different order by clauses in array_agg
aggregates.ArrayAgg[any]= 
aggregates.ArrayAgg[any,any]= 
aggregates.Collect[any]=

# 
# Distinct aggregates
# 
aggregates.Avg.distinct[any]=AVG(DISTINCT %1$s)
aggregates.Min.distinct[any]=MIN(DISTINCT %1$s)
aggregates.Max.distinct[any]=MAX(DISTINCT %1$s)
aggregates.Count.distinct[any]=COUNT(DISTINCT %1$s) 
aggregates.Sum.distinct[any]=SUM(DISTINCT %1$s)

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

# 
# Linear regression aggregates
# 
aggregates.Corr[any,any]=corr(%1$s, %2$s)
aggregates.CovarPop[any,any]=covar_pop(%1$s, %2$s)
aggregates.CovarSamp[any,any]=covar_samp(%1$s, %2$s)
# REGR_* functions to be implemented by JIRA SPARK-23907 (target is Spark 2.4)
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]=

# 
# Character scalar functions
# 

functions.CharLength[any]=LENGTH(%1$s)
functions.CharLength[clob]=
functions.OctetLength[any]=
functions.BitLength[text]=
functions.Upper[any]=UPPER(%1$s)
functions.Lower[any]=LOWER(%1$s)
functions.Substring[any,any]=substr(%1$s, cast(%2$s as int))
functions.Substring[any,any,any]=substr(%1$s, cast(%2$s as int), cast(%3$s as int))
functions.Position[any,any]= locate(%1$s, %2$s)
functions.Index[any,any]=
functions.Ascii[any]=
functions.Translate[any,any]= 
functions.Normalize[any]= 
functions.Normalize[any,any]= 
functions.Normalize[any,any,any]= 

#Substring function to negative START value to parse the input string from its rightmost end. 
#It's not a standard SQL function, so leave the definition empty.
functions.SubstringR[any,any]=
functions.SubstringR[any,any,any]=


#
# Regular expression functions.
#
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.Abs[any]=ABS(%1$s)
functions.Ceiling[any]=CEILING(%1$s)
functions.Exp[any]=EXP(%1$s)
functions.Floor[any]=FLOOR(%1$s)
# Ln failed exception cases
functions.Ln[any]=LN(%1$s)
functions.Log10[any]=LOG10(%1$s)
functions.Mod[any,any]=PMOD(%1$s, %2$s)
# Power failed exception cases
functions.Power[any,any]=POWER(%1$s, %2$s)
functions.Random[]=RAND()
functions.Random[any]=RAND(%1$s)
functions.Round[any]=ROUND(%1$s)
functions.Round[any,any]=ROUND(%1$s, %2$s)
functions.Round[any,any,any]=
functions.Sign[any]=SIGN(%1$s)
# Sqrt failed exception cases
functions.Sqrt[any]=SQRT(%1$s)
functions.WidthBucket[any,any,any,any]=WIDTH_BUCKET(%1$s, %2$s, %3$s, %4$s)

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

# 
# Trig Functions
# 
functions.Arccos[any]=ACOS(%1$s)
functions.Cos[any]=COS(%1$s)
functions.Coshyp[any]=COSH(%1$s)
functions.Arcsin[any]=ASIN(%1$s)
functions.Sin[any]=SIN(%1$s)
functions.Sinhyp[any]=SINH(%1$s)
functions.Arctan[any]=ATAN(%1$s)
functions.Tan[any]=TAN(%1$s)
functions.Tanhyp[any]=TANH(%1$s)

# 
# 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[]=
functions.LocalTime[numeric]= 
functions.LocalTimestamp[]=cast(from_unixtime( unix_timestamp()) as timestamp)
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=
functions.XMLElement.ContentOption.NULL_ON_NULL=false
functions.XMLElement.ContentOption.EMPTY_ON_NULL=false
functions.XMLForest.ContentOption.NULL_ON_NULL=false
functions.XMLForest.ContentOption.EMPTY_ON_NULL=false
functions.XMLParse.DocumentOrContent.DOCUMENT=false
functions.XMLParse.DocumentOrContent.CONTENT=false
functions.XMLParse.WhitespaceOption.STRIP_WHITESPACE=false
functions.XMLParse.WhitespaceOption.PRESERVE_WHITESPACE=false
functions.XMLQuery.EmptyHandlingOption.NULL_ON_EMPTY=true
functions.XMLQuery.EmptyHandlingOption.EMPTY_ON_EMPTY=true
functions.XMLSerialize.DeclarationOption.INCLUDING_XMLDECLARATION=false
functions.XMLSerialize.DeclarationOption.EXCLUDING_XMLDECLARATION=false

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

#
# Business date functions.
#
# cast timestamp to double to preserve fractional seconds versus unix_timestamp which is only to seconds
functions.AddFractionalSeconds[any,any]=add_nanos_ts(%1$s, %2$s)
#functions.AddFractionalSeconds[any,any]=cast(cast(%1$s as double) + %2$s as timestamp)
functions.AddSeconds[date,any]=
functions.AddSeconds[any,any]=add_seconds_ts(%1$s, %2$s)
#functions.AddSeconds[any,any]=cast(cast(%1$s as double) + cast(%2$s as int) as timestamp)
functions.AddMinutes[date,any]=
functions.AddMinutes[any,any]=add_minutes_ts(%1$s, %2$s)
#functions.AddMinutes[any,any]=cast(cast(%1$s as double) + (60 * cast(%2$s as int)) as timestamp)
functions.AddHours[date,any]=
functions.AddHours[any,any]=add_hours_ts(%1$s, %2$s)
#functions.AddHours[any,any]=cast(cast(%1$s as double) + (3600 * cast(%2$s as int)) as timestamp)
functions.AddDays[interval_day_time,numeric]=
functions.AddDays[date,numeric]=cast(date_add(%1$s, cast(%2$s as int)) as date)
functions.AddDays[timestamp,numeric]=add_days_ts(%1$s, %2$s)
functions.AddDays[timestamp_with_time_zone,numeric]=add_days_ts(%1$s, %2$s)
#functions.AddDays[timestamp,numeric]=cast(cast(%1$s as double) + (86400 * cast(%2$s as int)) as timestamp)
functions.AddWeeks[date,numeric]=add_weeks(%1$s, %2$s)
functions.AddWeeks[timestamp,numeric]=add_weeks_ts(%1$s, %2$s)
functions.AddWeeks[timestamp_with_time_zone,numeric]=add_weeks_ts(%1$s, %2$s)
#functions.AddWeeks[date,numeric]=cast(date_add(%1$s, cast(%2$s as int) * 7) as date)
#functions.AddWeeks[timestamp,numeric]=cast(cast(%1$s as double) + (604800 * cast(%2$s as int)) as timestamp)
# Using Spark's builtin add_months(date, int)
functions.AddMonths[date,numeric]=add_months(%1$s, cast(%2$s as int))
functions.AddMonths[timestamp,numeric]=add_months_ts(%1$s, %2$s)
functions.AddMonths[timestamp_with_time_zone,numeric]=add_months_ts(%1$s, %2$s)
functions.AddQuarters[date,numeric]=add_quarters(%1$s, %2$s)
functions.AddQuarters[timestamp,numeric]=add_quarters_ts(%1$s, %2$s)
functions.AddQuarters[timestamp_with_time_zone,numeric]=add_quarters_ts(%1$s, %2$s)
functions.AddYears[date,numeric]=add_years(%1$s, %2$s)
functions.AddYears[timestamp,numeric]=add_years_ts(%1$s, %2$s)
functions.AddYears[timestamp_with_time_zone,numeric]=add_years_ts(%1$s, %2$s)
#functions.AddYears[date,numeric]=cast(date_add(%1$s, cast(%2$s as int) * 365) as date)
functions.FractionalSecondsBetween[any,any]=fractional_seconds_between(%1$s, %2$s)
functions.SecondsBetween[any,any]=seconds_between(%1$s, %2$s)
#functions.SecondsBetween[any,any]=(unix_timestamp(%1$s) - unix_timestamp(%2$s))
functions.MinutesBetween[any,any]=minutes_between(%1$s, %2$s)
#functions.MinutesBetween[any,any]=cast((unix_timestamp(%1$s) - unix_timestamp(%2$s)) / 60 as bigint)
functions.HoursBetween[any,any]=hours_between(%1$s, %2$s)
#functions.HoursBetween[any,any]=cast((unix_timestamp(%1$s) - unix_timestamp(%2$s)) / 3600 as bigint)
functions.DaysBetween[any,any]=datediff(%1$s, %2$s)
functions.WeeksBetween[any,any]=weeks_between(%1$s, %2$s)
functions.MonthsBetween[any,any]=months_between(%1$s, %2$s)
functions.QuartersBetween[any,any]=quarters_between(%1$s, %2$s)
functions.YearsBetween[any,any]=years_between(%1$s, %2$s)
functions.DaysToEndOfMonth[any]=days_to_end_of_month(%1$s)
functions.Age[any]=ymdint_between(current_date, %1$s)
functions.FirstOfMonth[any]=
functions.FirstOfMonth[date]=first_of_month(%1$s)
functions.FirstOfMonth[timestamp]=first_of_month_ts(%1$s)
functions.FirstOfMonth[timestamp_with_time_zone]=first_of_month_ts(%1$s)
functions.LastOfMonth[any]=
functions.LastOfMonth[date]=last_of_month(%1$s)
functions.LastOfMonth[timestamp]=last_of_month_ts(%1$s)
functions.LastOfMonth[timestamp_with_time_zone]=last_of_month_ts(%1$s)
functions.MakeTimestamp[any,any,any]=make_timestamp(%1$s, %2$s, %3$s)
functions.DayOfYear[any]=day_of_year(%1$s)
functions.DayOfWeek[any,any]=day_of_week(%1$s, %2$s)
functions.WeekOfYear[any]=weekofyear(%1$s)
functions.YMDIntBetween[any,any]=ymdint_between(%1$s, %2$s)


# 
# Table functions
# 
functions.Unnest=

# 
# Literals
# 
literals.smallint=true
literals.decimal=true
literals.float=true
literals.char=false
literals.nchar=false
literals.varchar=true
literals.nvarchar=true
literals.blob=false
literals.clob=false
literals.nclob=false
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=false
literals.boolean=false
literals.xml=false
literals.array=false
literals.perioddate=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.time=cast( '1970-01-01 %1$02d:%2$02d:%3$02d%4$.10s' as timestamp )
literals.format.time_with_time_zone=TIME '%1$02d:%2$02d:%3$02d%4$.10s%7$c%5$02d:%6$02d'
literals.format.timestamp=cast( '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.10s' as timestamp )
literals.format.timestamp_with_time_zone=TIMESTAMP '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.10s%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$d' 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$.10s' DAY TO SECOND
literals.format.interval_hour=INTERVAL %3$s'%1$d' HOUR
literals.format.interval_hour_to_minute=INTERVAL %4$s'%1$02d:%2$02d' HOUR TO MINUTE
literals.format.interval_hour_to_second=INTERVAL %7$s'%1$02d:%2$02d:%3$02d%4$.10s' HOUR TO SECOND
literals.format.interval_minute=INTERVAL %3$s'%1$d' MINUTE
literals.format.interval_minute_to_second=INTERVAL %6$s'%1$02d:%2$02d%3$.10s' MINUTE TO SECOND
literals.format.interval_second=INTERVAL %3$s'%1$d%2$.10s' SECOND
literals.format.interval_year=INTERVAL %3$s'%1$d' YEAR
literals.format.interval_year_to_month=INTERVAL %4$s'%1$d-%2$d' YEAR TO MONTH
literals.format.interval_month=INTERVAL %3$s'%1$d' MONTH
# 1 parameter (string)
literals.format.nchar='%s'
# 1 parameter (string)
literals.format.varchar='%s'
# 1 parameter (string)
literals.format.nvarchar='%s'

# DataTypes
# 
dataType.binary=true
dataType.blob=false
dataType.clob=false
dataType.date=true
dataType.time=true
dataType.time_with_time_zone=false
dataType.timestamp=true
dataType.timestamp_with_time_zone=false
dataType.interval_day=false
dataType.interval_day_to_hour=false
dataType.interval_day_to_minute=false
dataType.interval_day_to_second=false
dataType.interval_hour=false
dataType.interval_hour_to_minute=false
dataType.interval_hour_to_second=false
dataType.interval_minute=false
dataType.interval_minute_to_second=false
dataType.interval_second=false
dataType.interval_year=false
dataType.interval_year_to_month=false
dataType.interval_month=false
dataType.decimal=true
dataType.char=true
dataType.nchar=false
dataType.nvarchar=true
dataType.xml=false
dataType.period=false
dataType.array=false
dataType.struct=false
dataType.map=false
dataType.json=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=SELECT 'FLINT' , 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 FROM ( values ( 1 ) ) T
# 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=

#
# Collation sequence mappings
# collation.sequence.mapping.<sql_result>=<collation_name>,<collation_weight>
#
# NOTE: These mappings are case sensitive
#
collation.sequence.mapping.FLINT=UnicodeCodepoint,IDENTICAL

# 
# 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