#Licensed Materials - Property of IBM
#
#OCO Source Materials
#
#BI and PM: rdbmscert
#
#(C) Copyright IBM Corp. 2016, 2020
#
#US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM corp.
#This properties file contains default configuration attributes for all
#
#relational data sources.  Any data source that is different must override
#
#the value in their own properties file.
#



#
# 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=*/
# delimiters.catalogDelimiter=
# delimiters.schemaDelimiter=
# delimiters.tableDelimiter=
# delimiters.columnDelimiter=
# delimiters.identifierQuoteString=
# delimiters.searchStringEscape=
# delimiters.catalogSeparator=

#
# Keywords
#
keywords.columnAlias=AS

#
# 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=1
# limits.maxTableNameLength=
# limits.maxTablesInSelect=
# limits.maxUserNameLength=
# limits.defaultTransactionIsolation=
# limits.maxLengthInClause

#
# General
#
#
# Null ordering
#
# No support is provided for vendors who change how nulls sort based on data type.
general.nullsAreSortedHigh=true
general.nullsAreSortedLow=false
general.nullsAreSortedAtStart=false
general.nullsAreSortedAtEnd=false
general.nullsOrdering=true
general.nullsOrderingInWindowSpecification=true

#
# 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 RANDOM
#
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=false
supports.fieldsOfComplexTypeInSelectList=false
supports.likeEscapeClause=true
supports.outerJoins=true
supports.fullOuterJoins=true
supports.subqueriesInComparisons=false
supports.subqueriesInExists=true
supports.subqueriesInIns=false
supports.subqueriesInQuantifieds=true
supports.subqueriesInOnClause=true
supports.subqueriesInCase=false
supports.correlatedSubqueries=true
supports.scalarSubqueries=true
supports.withClauseInDerivedTable=true
supports.nestedWithClause=true
supports.integerDivision=true
supports.nestedOlap=false
supports.derivedColumnLists=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.expressionsInGroupBy=false
# Does not allow grouping on non projected column
supports.thetaJoins=true
# Indicates whether inner joins require at least one equijoin predicate.
# A INNER JOIN B ON A.C1 = B.C1 AND A.C2 > B.C2 is fine, but A INNER JOIN B ON A.C2 > B.C2 is not.
supports.limitedThetaJoins=false
supports.equiJoins=true
supports.crossProducts=true
supports.recursiveWithClause=false
supports.constantsInWindows=false
supports.constantsInCount=true
supports.parameterMarkers=false
#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
#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

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

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

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

#
# Constructors - context overrides.
#
constructors.row.simpleCase=true
constructors.row.between=true
constructors.row.comparison=true
constructors.row.in=false
constructors.row.isDistinctFrom=false
#DB2 supports table value constructor in IN clause, but not row expression list.
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 SYSTEM (%1$s)@2[ REPEATABLE (%2$s)]
clauses.TableSampleBernoulli=TABLESAMPLE BERNOULLI (%1$s)@2[ REPEATABLE (%2$s)]
clauses.ForSystemTimeAsOf=
clauses.ForSystemTimeFrom=
clauses.ForSystemTimeBetween=

#
# 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
joins.RightNested=%1$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=
operators.logical.IsJson=CHECK_JSON( %1$s ) IS NULL
operators.logical.IsNotJson=CHECK_JSON( %1$s ) IS NOT NULL

#
# Arithmetic and Character operators
#
operators.arithmetic.Add[any,any]=%1$s + %2$s
operators.arithmetic.Subtract[any,datetime]=
operators.arithmetic.Subtract[any,numeric]=%1$s - %2$s
operators.arithmetic.Multiply[any,any]=%1$s * %2$s
operators.arithmetic.Divide[any,any]=%1$s / %2$s
operators.arithmetic.UnaryPlus[any]=+%1$s
operators.arithmetic.Negate[any]=-%1$s
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[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]=
predicates.IsNull=%1$s IS NULL
predicates.IsNotNull=%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=REGEXP_LIKE(%1$s, %2$s)
predicates.LikeRegex.flag=REGEXP_LIKE(%1$s, %2$s, %3$s)
predicates.Similar=
predicates.Similar.escape=
predicates.Exists=EXISTS %1$s
predicates.All=
predicates.Any=
predicates.Some=SOME %1$s
predicates.IsDistinctFrom[any,any]=%1$s IS DISTINCT FROM %2$s
predicates.IsNotDistinctFrom[any,any]=%1$s IS NOT DISTINCT FROM %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[datetime,date]=COALESCE(%1$s)
expressions.Coalesce[datetime,string]=COALESCE(%1$s)
expressions.Coalesce[datetime,varchar]=
expressions.Coalesce[datetime,numeric]=COALESCE(%1$s)
expressions.Coalesce[datetime,time]=
expressions.Coalesce[datetime,timestamp]=COALESCE(%1$s)
expressions.Coalesce[string,date]=COALESCE(%1$s)
expressions.Coalesce[string,string]=COALESCE(%1$s)
expressions.Coalesce[string,varchar]=
expressions.Coalesce[string,numeric]=COALESCE(%1$s)
expressions.Coalesce[string,time]=
expressions.Coalesce[string,timestamp]=COALESCE(%1$s)
expressions.Coalesce[varchar,any]=COALESCE(%1$s)
expressions.Coalesce[numeric,date]=COALESCE(%1$s)
expressions.Coalesce[numeric,string]=COALESCE(%1$s)
expressions.Coalesce[numeric,varchar]=
expressions.Coalesce[numeric,numeric]=COALESCE(%1$s)
expressions.Coalesce[numeric,time]=
expressions.Coalesce[numeric,timestamp]=COALESCE(%1$s)
expressions.Coalesce.minArgs=2
expressions.NullIf[any,any]=NULLIF(%1$s, %2$s)

#
# Cast
#
# Cannot cast from null value to TimestampWithTZ
expressions.Cast[any,any]=CAST(%1$s AS %2$s)
expressions.Cast[smallint,char]=
expressions.Cast[integer,char]=
expressions.Cast[long,char]=
expressions.Cast[decimal,char]=
expressions.Cast[float,text]=
expressions.Cast[double,text]=
expressions.Cast[char,char]=
expressions.Cast[text,timestamp]=cast(%1$s as timestamp without time zone)
expressions.Cast[char,timestamp_with_time_zone]=
expressions.Cast[varchar,timestamp_with_time_zone]=
expressions.Cast[date,timestamp_with_time_zone]=
expressions.Cast[time,char]=
expressions.Cast[time,varchar]=
expressions.Cast[time,timestamp]=
expressions.Cast[time,timestamp_with_time_zone]=
expressions.Cast[timestamp,text]=
expressions.Cast[timestamp,time]=
expressions.Cast[timestamp,timestamp_with_time_zone]=
expressions.Cast[timestamp_with_time_zone,text]=
expressions.Cast[timestamp_with_time_zone,time]=
expressions.Cast[timestamp_with_time_zone,timestamp_with_time_zone]=
#
# 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)
expressions.Extract.SECOND[any]=
expressions.Extract.TIMEZONE_HOUR[any]=EXTRACT(TZH FROM %1$s)
expressions.Extract.TIMEZONE_MINUTE[any]=EXTRACT(TZM FROM %1$s)
expressions.Extract.EPOCH[any]=
#
# Trim
#
expressions.Trim.BOTH[any]=TRIM(%1$s)
expressions.Trim.BOTH[any,any]=TRIM(%2$s, %1$s)
expressions.Trim.LEADING[any]=LTRIM(%1$s)
expressions.Trim.LEADING[any,any]=LTRIM(%2$s, %1$s)
expressions.Trim.TRAILING[any]=RTRIM(%1$s)
expressions.Trim.TRAILING[any,any]=RTRIM(%2$s, %1$s)

#
# Windowed aggregates (SQL/OLAP).
#
olap.Max[any]=MAX(%1$s)
olap.Min[any]=MIN(%1$s)
olap.Sum[any]=SUM(%1$s)
# While Snowflake has enhanced their windowed aggregate support in 1.86.0, they impose restrictions on AVG
# Cumulative window frame unsupported for function AVG
# Sliding window frame unsupported for function AVG
#olap.Avg[any]=AVG(%1$s)
olap.Avg[any]=
olap.Count[any]=COUNT(%1$s)
# Snowflake aggregate support added in 1.86.0 refuses count(*) but accepts count (1) which is used as a workarond
olap.CountStar[]=COUNT(1)
#olap.CountStar[]=COUNT(*)
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.RatioToReport[any]=
olap.Median[any]=MEDIAN(%1$s)
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]=NTILE(%1$s)
olap.Tertile[]=
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.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]=LEAD(%1$s, %2$s, %3$s) %4$s
olap.NthValue[any]=
olap.NthValue[any,any]=
olap.NthValue[any,any,any]=NTH_VALUE(%1$s, %2$s) %3$s
olap.NthValue[any,any,any,any]=
olap.Collect[any]=

#
# Window clause
#
olap.Window=OVER(%1$s)
olap.PartitionBy=PARTITION BY %1$s
olap.OrderBy=ORDER BY %1$s

#
# Window specification
#
olap.Window.Specification[POF]=true
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.Window.Frame.Moving=true

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

#
# Aggregates
#
aggregates.Min[any]=MIN(%1$s)
aggregates.Min[timestamp_with_time_zone]=
aggregates.Min[time]=
aggregates.Max[any]=MAX(%1$s)
aggregates.Max[timestamp_with_time_zone]=
aggregates.Max[time]=
aggregates.Sum[any]=SUM(%1$s)
aggregates.Avg[any]=AVG(%1$s)
aggregates.Count[any]=COUNT(%1$s)
aggregates.CountStar[]=COUNT(*)
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.PercentileDisc[any,any]=PERCENTILE_DISC(%1$s) WITHIN GROUP (ORDER BY %2$s)
aggregates.PercentileCont[any,any]=PERCENTILE_CONT(%1$s) WITHIN GROUP (ORDER BY %2$s)
aggregates.Median[any]=MEDIAN(%1$s)
aggregates.Grouping[any]=
aggregates.XMLAgg[any]=
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)

#
# 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)
aggregates.RegrAvgX[any,any]=REGR_AVGX(%1$s, %2$s)
aggregates.RegrAvgY[any,any]=REGR_AVGY(%1$s, %2$s)
aggregates.RegrCount[any,any]=REGR_COUNT(%1$s, %2$s)
aggregates.RegrIntercept[any,any]=REGR_INTERCEPT(%1$s, %2$s)
aggregates.RegrR2[any,any]=REGR_R2(%1$s, %2$s)
aggregates.RegrSlope[any,any]=REGR_SLOPE(%1$s, %2$s)
aggregates.RegrSXX[any,any]=REGR_SXX(%1$s, %2$s)
aggregates.RegrSXY[any,any]=REGR_SXY(%1$s, %2$s)
aggregates.RegrSYY[any,any]=REGR_SYY(%1$s, %2$s)

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

#
# Character scalar functions
#

functions.CharLength[any]=LENGTH(%1$s)
functions.OctetLength[any]=OCTET_LENGTH(%1$s)
functions.BitLength[any]=BIT_LENGTH(%1$s)
functions.Upper[any]=UPPER(%1$s)
functions.Lower[any]=LOWER(%1$s)
functions.Substring[any,any]=SUBSTRING(%1$s, TRUNC(%2$s))
functions.Substring[any,any,any]=SUBSTRING(%1$s, TRUNC(%2$s), TRUNC(%3$s))
functions.Position[any,any]=POSITION(%1$s IN %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,nullArg,nullArg,nullArg]=REGEXP_SUBSTR(%2$s,%1$s)
functions.SubstringRegex[any,any,any,nullArg,nullArg]=REGEXP_SUBSTR(%2$s,%1$s,%3$s)
functions.SubstringRegex[any,any,any,any,nullArg]=REGEXP_SUBSTR(%2$s,%1$s,%3$s,%4$s)
functions.SubstringRegex[any,any,any,any,any]=REGEXP_SUBSTR(%2$s,%1$s,%3$s,%4$s,%5$s)
functions.SubstringRegex[any,any,any,nullArg,any]=
functions.SubstringRegex[any,any,nullArg,any,any]=
functions.SubstringRegex[any,any,nullArg,any,nullArg]=
functions.SubstringRegex[any,any,nullArg,nullArg,any]=
functions.OccurrencesRegex[any,any,nullArg,nullArg]=REGEXP_COUNT(%2$s,%1$s)
functions.OccurrencesRegex[any,any,any,nullArg]=REGEXP_COUNT(%2$s,%1$s,%3$s)
functions.OccurrencesRegex[any,any,any,any]=REGEXP_COUNT(%2$s,%1$s,%3$s,%4$s)
functions.OccurrencesRegex[any,any,nullArg,any]=
functions.PositionRegex[null,any,any,nullArg,nullArg,nullArg]=REGEXP_INSTR(%3$s,%2$s)
functions.PositionRegex[null,any,any,any,nullArg,nullArg]=REGEXP_INSTR(%3$s,%2$s,%4$s)
functions.PositionRegex[null,any,any,any,any,nullArg]=REGEXP_INSTR(%3$s,%2$s,%4$s,%5$s)
functions.PositionRegex[any,any,any,any,any,any]=REGEXP_INSTR(%3$s,%2$s,%4$s,%5$s,%6$s,%1$s)

#
# Numeric scalar functions
#
functions.Abs[any]=ABS(%1$s)
functions.Ceiling[any]=CEIL(%1$s)
functions.Exp[any]=EXP(%1$s)
functions.Floor[any]=FLOOR(%1$s)
functions.Ln[any]=LN(%1$s)
functions.Log10[any]=
functions.Mod[any,any]=MOD(%1$s, %2$s)
functions.Power[any,any]=POWER(%1$s, %2$s)
functions.Random[]=CAST((RANDOM() + 9223372036854775807) AS DOUBLE PRECISION) / 18446744073709551615
functions.Random[any]=CAST((RANDOM(%1$s) + 9223372036854775807) AS DOUBLE PRECISION) / 18446744073709551615
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)
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[]=CURRENT_TIMESTAMP
functions.CurrentTimestamp[numeric]=
functions.LocalTime[]=LOCALTIME
functions.LocalTime[numeric]=
functions.LocalTimestamp[]=LOCALTIMESTAMP
functions.LocalTimestamp[numeric]=LOCALTIMESTAMP(%1$s)

#
# 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=false
functions.XMLQuery.EmptyHandlingOption.EMPTY_ON_EMPTY=false
functions.XMLSerialize.DeclarationOption.INCLUDING_XMLDECLARATION=false
functions.XMLSerialize.DeclarationOption.EXCLUDING_XMLDECLARATION=false

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



#
# Business date functions.
#
functions.AddHours[any,any]=DATEADD(HOURS, TRUNC(%2$s), %1$s)
functions.AddMinutes[any,any]=DATEADD(MINUTES, TRUNC(%2$s), %1$s)
functions.AddSeconds[any,any]=DATEADD(SECONDS, %2$s, %1$s)
functions.AddFractionalSeconds[any,any]=
functions.AddDays[any,any]=DATEADD(DAYS, TRUNC(%2$s), %1$s)
functions.AddWeeks[any,any]=DATEADD(WEEK, TRUNC(%2$s), %1$s)
functions.AddMonths[any,any]=DATEADD(MONTH, TRUNC(%2$s), %1$s)
functions.AddQuarters[any,any]=DATEADD(QUARTERS, TRUNC(%2$s), %1$s)
functions.AddYears[any,any]=DATEADD(YEARS, TRUNC(%2$s), %1$s)
functions.Age[any]=
functions.FractionalSecondsBetween[any,any]=
functions.SecondsBetween[any,any]=DATEDIFF(SECONDS, %1$s, %2$s)
functions.MinutesBetween[any,any]=DATEDIFF(MINUTES, %1$s, %2$s)
functions.HoursBetween[any,any]=DATEDIFF(HOURS, %1$s, %2$s)
functions.DaysBetween[any,any]=DATEDIFF(DAYS, %1$s, %2$s)
functions.WeeksBetween[any,any]=DATEDIFF(WEEK, %1$s, %2$s)
functions.MonthsBetween[any,any]=DATEDIFF(MONTHS,%1$s, %2$s)
functions.QuartersBetween[any,any]=DATEDIFF(QUARTERS,%1$s, %2$s)
functions.YearsBetween[any,any]=DATEDIFF(YEARS, %1$s, %2$s)
functions.DayOfWeek[any,any]=
functions.DayOfYear[any]=EXTRACT(DAYOFYEAR, %1$s)
# do not push to snowflake - functions.DaysToEndOfMonth[any]
# error from snowflake : not enough arguments for function [DATEDIFF(CAST(TTS.CTS AS DATE), LASTDAYOFMONTH(CAST(TTS.CTS AS DATE)))], expected 3, got 2  SQLState:  22023  ErrorCode: 938
functions.DaysToEndOfMonth[any]=
functions.FirstOfMonth[any]=DATEADD( DAY, -(EXTRACT (DAY, %1$s) - 1), %1$s)
functions.LastOfMonth[any]=LAST_DAY(%1$s)
functions.MakeTimestamp[any,any,any]=
functions.WeekOfYear[any]=EXTRACT(WEEK, %1$s)
functions.YMDIntBetween[any,any]=

#
# Table functions.
#
functions.Unnest=

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

#
# Literal constraints.
#
literals.time.fractional_seconds=true

#
# 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.
# Literal format in specific context: literals.format.<datatype>.<context>
# Currently only 'procedure' is supported and denotes stored procedure parameter.
#	  ex. literals.format.date.procedure={d '%1$04d-%2$02d-%3$02d'}
# 1 parameter (string)
literals.format.binary=
# 1 parameter (string)
literals.format.clob='%s'
# colon separated values for TRUE, FALSE and UNKNOWN
literals.format.boolean=TRUE:FALSE:NULL
# 3 parameters (int year, int month, int day)
literals.format.date=to_date ('%1$04d-%2$02d-%3$02d', 'YYYY-MM-DD')
# 4 parameters (int hour, int minute, int seconds, string fractional seconds)
literals.format.time=to_time ( '%1$02d:%2$02d:%3$02d%4$.10s', 'HH:MI:SS.FF9' )
# 7 parameters (int hour, int minute, int seconds, string fractional seconds, int tz hour, int tz minute, char tz sign)
literals.format.time_with_time_zone=
# 7 parameters (int year, int month, int day, int hours, int minute, int seconds, string fractional seconds)
literals.format.timestamp=to_timestamp( '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.10s', 'YYYY-MM-DD HH:MI:SS.FF' )
# 10 parameters (int year, int month, int day, int hours, int minute, int seconds, string fractional seconds, int tz hour, int tz minute, char tz sign)
literals.format.timestamp_with_time_zone=to_timestamp_tz( '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.10s%10$c%8$02d:%9$02d', 'YYYY-MM-DD HH:MI:SS.FF9TZH:TZM')
# 3 parameters (int day, int leading precision, char sign)
literals.format.interval_day=
# 4 parameters (int day, int hour, int leading precision, char sign)
literals.format.interval_day_to_hour=
# 5 parameters (int day, int hour, int minute, int leading precision, char sign)
literals.format.interval_day_to_minute=
# 8 parameters (int day, int hour, int minute, int seconds, string fractional seconds, int leading precision, int fractional precision, char sign)
literals.format.interval_day_to_second=
# 3 parameters (int hour, int leading precision, char sign)
literals.format.interval_hour=
# 4 parameters (int hour, int minute, int leading precision, char sign)
literals.format.interval_hour_to_minute=
# 7 parameters (int hour, int minute, int seconds, string fractional seconds, int leading precision, int fractional precision, char sign)
literals.format.interval_hour_to_second=
# 3 parameters (int minute, int leading precision, char sign)
literals.format.interval_minute=
# 6 parameters (int minute, int seconds, string fractional seconds, int leading precision, int fractional precision, char sign)
literals.format.interval_minute_to_second=
# 5 parameters (int seconds, string fractional seconds, int leading precision, int fractional precision, char sign)
literals.format.interval_second=
# 3 parameters (int year, int leading precision, char sign)
literals.format.interval_year=
# 4 parameters (int year, int month, int leading precision, char sign)
literals.format.interval_year_to_month=
# 3 parameters (int month, int leading precision, char sign)
literals.format.interval_month=
# 1 parameter (string)
literals.format.decimal=%s
# 1 parameter (string)
literals.format.char='%s'
# 1 parameter (string)
literals.format.nchar=
# 1 parameter (string)
literals.format.varchar='%s'
# 1 parameter (string)
literals.format.nvarchar=

#
# Data types.
#
dataType.binary=false
dataType.blob=false
dataType.clob=false
dataType.boolean=true
dataType.date=true
dataType.time=true
dataType.time_with_time_zone=true
dataType.timestamp=true
dataType.timestamp_with_time_zone=true
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.smallint=false
dataType.integer=false
dataType.long=false
dataType.float=true
dataType.double=true
dataType.decimal=true
dataType.char=false
dataType.nchar=false
dataType.varchar=true
dataType.nvarchar=false
dataType.xml=false
dataType.period=false
dataType.array=false
dataType.struct=false
dataType.map=false
dataType.json=false
dataType.datalink=false

#
# dataType.comparable
# Used to indicate that some data types that are comparable locally may not
# be supported by the DB.
#
#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

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