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

# 
# Delimiters
# 
# While a vendor may parse a statement with comments it may strip them out and the server not see them
# db2 iSeries returns character / for catalogSeparator, but it works only for qualified table,
# not for qualified column.  Overwrite with character . for both cli and iSeries
delimiters.catalogSeparator=.
delimiters.commentBegin=/*
delimiters.commentEnd=*/

# 
# Keywords
# 
keywords.columnAlias=AS

#
# Various limits
#
limits.castClobToVarcharMaxSize=30000

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

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

# 
# Various Features
# 
supports.duplicateColumnsInSelectList=true
supports.columnAliasing=true
supports.tableCorrelationNames=true
supports.expressionsInOrderBy=true
supports.expressionsInOrderByOnGroupedQuery=false
supports.orderByAlias=true
supports.orderByName=true
supports.orderByOrdinal=true
supports.expressionsInINPredicate=true
supports.likeEscapeClause=true
supports.fullOuterJoins=true
supports.outerJoins=true
supports.subqueriesInComparisons=true
supports.subqueriesInExists=true
supports.subqueriesInIns=true
supports.subqueriesInQuantifieds=true
supports.subqueriesInCase=false
supports.subqueriesInAggregate=false
supports.correlatedSubqueries=true
supports.scalarSubqueries=true
supports.withClauseInDerivedTable=false
supports.nestedWithClause=false
supports.recursiveWithClause=false
supports.integerDivision=true
supports.nestedOlap=false
supports.derivedColumnLists=true
supports.blobsInGroupBy=false
supports.blobsInOrderBy=false
supports.emptyStringIsNull=false
supports.expressionsInGroupBy=false
supports.stitchJoins=false
supports.rowNumberNoOrderBy=true
supports.callProcedureInDerivedTable=false
supports.join.subqueriesInOnClause=false
supports.castClobToVarcharWithoutSubstring=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=true
constructors.row=true
constructors.array=false
constructors.period=false

#
# Constructors - context overrides.
#

constructors.row.simpleCase=false
constructors.row.between=false
constructors.row.isDistinctFrom=false
#DB2 supports table value constructor in IN clause, but not row expression list.
constructors.row.inListToTable=true

# 
# Clauses
# 
clauses.From=FROM
clauses.Where=WHERE
clauses.GroupBy=GROUP BY
clauses.Having=HAVING
clauses.With=WITH
clauses.OrderBy=ORDER BY
clauses.Distinct=DISTINCT
clauses.Window=
clauses.WithRecursive=
clauses.At=
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
# 
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
# 
operators.arithmetic.Add[any,any]=%1$s + %2$s
operators.arithmetic.Multiply[any,any]=%1$s * %2$s
operators.arithmetic.Divide[any,any]=%1$s / %2$s
operators.arithmetic.Divide[smallint,decimal]= 
operators.arithmetic.Divide[smallint,double]= 
operators.arithmetic.Divide[smallint,float]= 
operators.arithmetic.Divide[long,decimal]= 
operators.arithmetic.Divide[long,double]= 
operators.arithmetic.Divide[long,float]= 
operators.arithmetic.Divide[integer,decimal]= 
operators.arithmetic.Divide[integer,double]= 
operators.arithmetic.Divide[integer,float]= 
operators.arithmetic.UnaryPlus[any]=+%1$s
operators.arithmetic.Negate[any]=-%1$s
operators.arithmetic.Concat[any,any]=%1$s || %2$s
operators.arithmetic.Subtract[any,datetime]=

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

# 
# Various Predicates
# 
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.Similar.escape= 
predicates.Exists=EXISTS %1$s
predicates.All=ALL %1$s
predicates.Some=SOME %1$s
predicates.Overlaps[any,any,any,any]=
predicates.LikeRegex=
predicates.LikeRegex.flag=
predicates.Similar=
predicates.Similar.escape=
predicates.Between[date,timestamp,any]=
predicates.Between[date,any,timestamp]=
predicates.Between[timestamp,date,any]=
predicates.Between[timestamp,any,date]=
predicates.In[date,timestamp]=
predicates.In[timestamp,date]=

#
# 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
# 
expressions.SimpleCase=CASE
expressions.SearchedCase=CASE
expressions.Coalesce=COALESCE(%1$s)
expressions.NullIf=NULLIF(%1$s, %2$s)

# 
# Cast
# 

expressions.Cast[time,char]=cast(char(%1$s,JIS) as %2$s)
expressions.Cast[time,varchar]=cast(char(%1$s,JIS) as %2$s)
expressions.Cast[date,timestamp]=timestamp(%1$s,'00:00:00')
expressions.Cast[timestamp,char]=cast(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF6') as %2$s)
expressions.Cast[timestamp,varchar]=cast(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF6') as %2$s) 
expressions.Cast[time,nchar]=cast(char(%1$s,JIS) as CHAR(%3$d))
expressions.Cast[time,nvarchar]=cast(char(%1$s,JIS) as VARCHAR(%3$d))
expressions.Cast[timestamp,nchar]=cast(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF6') as CHAR(%3$d)) 
expressions.Cast[timestamp,nvarchar]=cast(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF6') as VARCHAR(%3$d)) 
expressions.Cast[any,nchar]=cast((%1$s) as CHAR(%3$d))
expressions.Cast[any,nvarchar]=cast((%1$s) as VARCHAR(%3$d))
expressions.Cast[any,xml]=

# 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)
expressions.Extract.SECOND[any]=EXTRACT(SECOND FROM %1$s)
expressions.Extract.TIMEZONE_HOUR[any]=
expressions.Extract.TIMEZONE_MINUTE[any]=
expressions.Extract.EPOCH[any]=

# 
# Trim
# 
expressions.Trim.BOTH[any]=TRIM(BOTH FROM %1$s)
expressions.Trim.LEADING[any]=TRIM(LEADING FROM %1$s)
expressions.Trim.TRAILING[any]=TRIM(TRAILING FROM %1$s)

# 
# Aggregates
# 
aggregates.Max[any]=MAX(%1$s)
aggregates.Min[any]=MIN(%1$s)
aggregates.Count[any]=COUNT_BIG(%1$s)
aggregates.CountStar[]=COUNT_BIG(*)
aggregates.Sum[any]=SUM(%1$s)
aggregates.Avg[any]=AVG(%1$s)
aggregates.Avg[smallint]= 
aggregates.Avg[long]=
aggregates.StdDevPop[any]=
aggregates.StdDevSamp[any]=
aggregates.VarPop[any]=
aggregates.VarSamp[any]=
aggregates.Grouping[any]=
aggregates.CumeDistH[any,any]=
aggregates.PercentileCont[any,any]=
aggregates.PercentileDisc[any,any]=
aggregates.Median[any]=
aggregates.XMLAgg=XMLAGG(%1$s)
aggregates.ArrayAgg[any]=
aggregates.ArrayAgg[any,any]=
aggregates.Collect[any]=
aggregates.ApproxCountDistinct[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]=
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]=(OCTET_LENGTH(%1$s) * 8)
functions.Upper[any]=UPPER(%1$s)
functions.Lower[any]=LOWER(%1$s)
functions.Index[any,any]=POSITION(%2$s IN %1$s)
functions.Position[any,any]=POSITION(%1$s IN %2$s)
functions.Substring[any,any]=SUBSTR(%1$s, %2$s)
functions.Substring[any,any,any]=SUBSTR(%1$s, %2$s, %3$s)
functions.Translate[any,any]=
functions.Normalize[any]=
functions.Normalize[any,any]=
functions.Normalize[any,any,any]=
functions.Round[any,any,any]=
functions.Round[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.Abs[interval_day_time]=
functions.Abs[interval_year_month]=
functions.Ceiling[any]=
functions.Exp[any]=EXP(%1$s)
functions.Floor[any]=
functions.Ln[any]=LN(%1$s)
functions.Log10[any]=LOG10(%1$s)
functions.Sign[any]=SIGN(%1$s)
functions.Sqrt[any]=SQRT(%1$s)
functions.WidthBucket[any,any,any,any]=

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

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

# 
# Olap Functions
# 
olap.Min[any]=MIN(%1$s) 
olap.Max[any]=MAX(%1$s) 
olap.Sum[any]=SUM(%1$s) 
olap.Avg[any]=AVG(%1$s) 
olap.Count[any]=COUNT(%1$s) 
olap.CountStar[]=COUNT(*)
olap.CumeDist[]=CUME_DIST()
olap.LastValue[any]=LAST_VALUE(%1$s)
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]=LAG(%1$s, %2$s, %3$s) %4$s
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.NTile[any]=NTILE(%1$s)
olap.FirstValue[any]=FIRST_VALUE(%1$s)
olap.Tertile[]=
olap.Rank[]=RANK()
olap.DenseRank[]=DENSE_RANK()
olap.PercentRank[]=
olap.PercentileCont[any,any]=
olap.PercentileDisc[any,any]=
olap.RatioToReport[any]=RATIO_TO_REPORT(%1$s)
olap.RowNumber[]=ROW_NUMBER()
olap.Difference[any]=
olap.NthValue[any,any]=NTH_VALUE(%1$s, %2$s)
olap.NthValue[any,any,any]=NTH_VALUE(%1$s, %2$s) %3$s
olap.NthValue[any,any,any,any]=NTH_VALUE(%1$s, %2$s) %3$s %4$s
olap.Median[any]=
olap.StdDevSamp[any]=STDDEV_SAMP(%1$s)
olap.StdDevPop[any]=STDDEV_POP(%1$s)
olap.VarSamp[any]=VAR_SAMP(%1$s)
olap.VarPop[any]=VAR_POP(%1$s)
olap.Collect[any]=

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

#
# Window specification
# A list of windows specifications that are supported by the DB
# P = PARTITION BY
# O = ORDER BY
# F = FRAME 
# These settings are NOT consulted for the following functions:
# RANK, DENSE_RANK, PERCENT_RANK, LAG, LEAD, NTILE and ROW_NUMBER.
#
#unbounded preceding and current row not supported.
olap.Window.Specification[POF]=true
olap.Window.Specification[PO]=true
olap.Window.Specification[OF]=true
olap.Window.Specification[PF]=false
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).
#
olap.Max.distinct[any]=MAX(DISTINCT %1$s)
olap.Min.distinct[any]=MIN(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)

# 
# Temporal value expressions
# 
functions.CurrentDate[]=CURRENT_DATE
functions.CurrentTime[]=CURRENT_TIME
functions.CurrentTime[numeric]=
functions.CurrentTimestamp[]=CURRENT_TIMESTAMP
functions.CurrentTimestamp[numeric]= 
functions.LocalTime[]= LOCALTIME
functions.LocalTime[numeric]= 
functions.LocalTimestamp[]=LOCALTIMESTAMP
functions.LocalTimestamp[numeric]= 

# 
# XML Functions
# 
functions.XMLAttributes= 
functions.XMLComment= 
functions.XMLConcat=XMLConcat(%1$s)
functions.XMLExists= 
functions.XMLNamespaces= 
functions.XMLParse=
functions.XMLPI= 
functions.XMLQuery= 
functions.XMLSerialize= 
functions.XMLTable= 
functions.XMLText= 
functions.XMLTransform= 
functions.XMLValidate=
#jt400 driver 10.6/10.7 return clob instead of xml 
functions.XMLElement.ContentOption.NULL_ON_NULL=false
functions.XMLElement.ContentOption.EMPTY_ON_NULL=false
functions.XMLParse.DocumentOrContent.CONTENT=false
functions.XMLQuery.EmptyHandlingOption.NULL_ON_EMPTY=false

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

# 
# Business date functions.
# 

functions.AddFractionalSeconds[any,any]=
functions.AddSeconds[time,numeric]=(TIME(%1$s) + (%2$s) SECOND)
functions.AddSeconds[timestamp,numeric]=(TIMESTAMP(%1$s) + (%2$s) SECOND)
functions.AddSeconds[time_with_time_zone,numeric]=
functions.AddSeconds[timestamp_with_time_zone,numeric]=
functions.AddSeconds[interval_day_time,numeric]=((%1$s) + (%2$s) SECOND)
functions.AddMinutes[interval_day_time,numeric]=((%1$s) + (%2$s) MINUTE)
functions.AddMinutes[time,numeric]=(TIME(%1$s) + (%2$s) MINUTE)
functions.AddMinutes[timestamp,numeric]=(TIMESTAMP(%1$s) + (%2$s) MINUTE)
functions.AddMinutes[time_with_time_zone,numeric]=
functions.AddMinutes[timestamp_with_time_zone,numeric]=
functions.AddHours[interval_day_time,numeric]=((%1$s) + (%2$s) HOUR)
functions.AddHours[time,numeric]=TIME(%1$s) + (%2$s) HOUR
functions.AddHours[timestamp,numeric]=(TIMESTAMP(%1$s) + (%2$s) HOUR)
functions.AddHours[time_with_time_zone,numeric]=
functions.AddHours[timestamp_with_time_zone,numeric]=
functions.AddDays[any,any]=((%1$s) + (%2$s) DAY)
functions.AddDays[timestamp_with_time_zone,numeric]=
functions.AddWeeks[any,any]=((%1$s) + (%2$s * 7) DAY)
functions.AddWeeks[timestamp_with_time_zone,numeric]=
functions.AddMonths[any,any]=((%1$s) + (%2$s) MONTH)
functions.AddMonths[timestamp_with_time_zone,numeric]=
functions.AddQuarters[any,any]=((%1$s) + (%2$s * 3) MONTH)
functions.AddQuarters[timestamp_with_time_zone,numeric]=
functions.AddYears[any,any]=((%1$s) + (%2$s) YEAR)
functions.AddYears[timestamp_with_time_zone,numeric]=
functions.FractionalSecondsBetween[any,any]=
functions.SecondsBetween[time,time]=TIMESTAMPDIFF(2, CHAR((TIMESTAMP(CURRENT_DATE, %1$s)-TIMESTAMP(CURRENT_DATE, %2$s)))) 
functions.SecondsBetween[timestamp,timestamp]=TIMESTAMPDIFF(2, CHAR((TIMESTAMP(%1$s)-TIMESTAMP(%2$s)))) 
functions.MinutesBetween[time,time]=TIMESTAMPDIFF(4, CHAR((TIMESTAMP(CURRENT_DATE, %1$s)-TIMESTAMP(CURRENT_DATE, %2$s))))
functions.MinutesBetween[timestamp,timestamp]=TIMESTAMPDIFF(4, CHAR((TIMESTAMP(%1$s)-TIMESTAMP(%2$s))))
functions.HoursBetween[time,time]=TIMESTAMPDIFF(8, CHAR((TIMESTAMP(CURRENT_DATE, %1$s)-TIMESTAMP(CURRENT_DATE, %2$s)))) 
functions.HoursBetween[timestamp,timestamp]=TIMESTAMPDIFF(8, CHAR((TIMESTAMP(%1$s)-TIMESTAMP(%2$s))))
functions.DaysBetween[any,any]=(DAYS(%1$s) - DAYS(%2$s))
functions.WeeksBetween[any,any]=
functions.MonthsBetween[any,any]=
functions.QuartersBetween[any,any]=
functions.YearsBetween[any,any]=TIMESTAMPDIFF(256, char(TIMESTAMP(cast(%1$s as DATE),'00:00:00') - TIMESTAMP(cast(%2$s as DATE),'00:00:00')))
functions.YearsBetween[date,timestamp]=TIMESTAMPDIFF(256, char(TIMESTAMP(%1$s, '00:00:00') - TIMESTAMP(cast(%2$s as DATE),'00:00:00')))
functions.YearsBetween[timestamp,date]=TIMESTAMPDIFF(256, char(TIMESTAMP(cast(%1$s as DATE),'00:00:00') - TIMESTAMP(%2$s, '00:00:00')))
functions.YearsBetween[date,date]=TIMESTAMPDIFF(256, char(TIMESTAMP(%1$s, '00:00:00') - TIMESTAMP(%2$s, '00:00:00')))
functions.Age[any]=(CURRENT DATE - %1$s)
functions.DayOfWeek[any,any]=(MOD( DAYOFWEEK( %1$s ) - 1 + 7 - %2$s, 7 ) + 1)
functions.DayOfYear[any]=DAYOFYEAR( %1$s )
functions.DaysToEndOfMonth[any]=
functions.FirstOfMonth[any]=(%1$s - (DAY(%1$s)-1) DAY)
functions.LastOfMonth[any]=(%1$s - (DAY(%1$s)-1) DAY + 1 MONTH - 1 DAY)
functions.WeekOfYear[any]=WEEK_ISO(%1$s)
functions.MakeTimestamp[any,any,any]=TIMESTAMP_ISO( DATE( CHAR( RIGHT( DIGITS( %1$s ), 4 ) || '-' || RIGHT( DIGITS( %2$s ), 2 ) || '-' || RIGHT( DIGITS( %3$s ), 2 ) ) ) )
functions.YMDIntBetween[any,any]=

# 
# 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=false
literals.boolean=true
literals.xml=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.
literals.format.boolean=TRUE:FALSE:UNKNOWN
literals.format.char='%s'
literals.format.varchar='%s'
literals.format.nchar=N'%s'
literals.format.nvarchar=N'%s'
literals.format.clob='%s'
literals.format.date=DATE('%1$04d-%2$02d-%3$02d') 
literals.format.interval_day=%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_month=%3$s%1$d MONTH
literals.format.interval_second=INTERVAL %3$s'%1$d%2$.10s' SECOND
literals.format.interval_year=%3$s%1$d YEAR
literals.format.interval_year_to_month=INTERVAL %4$s'%1$d-%2$d' YEAR TO MONTH
literals.format.time=TIME('%1$02d:%2$02d:%3$02d') 
literals.format.time_with_time_zone=TIME'%1$02d:%2$02d:%3$02d%4$.10s%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$.10s%10$c%8$02d:%9$02d'

# 
# DataTypes
# 
dataType.smallint=true
dataType.integer=true
dataType.long=true
dataType.decimal=true
dataType.float=true
dataType.double=true
dataType.char=true
dataType.nchar=true
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
#datasource.type.XML=xml
#datasource.type.GRAPHIC=char
#datasource.type.VARGRAPHIC=varchar
#datasource.type.DECFLOAT=double