analytics/configuration/xqe/db2.dashdb.properties

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

#
# Product information.
#

#
# Delimiters.
#

#
# Keywords.
#

#
# Various limits.
#
limits.castClobToVarcharMaxSize=8168

#
# General settings.
#
general.nullsAreSortedHigh=true
general.nullsOrdering=false

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

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

#
# Various features.
#
supports.subqueriesInAggregate=false
supports.withClauseInDerivedTable=false
supports.nestedWithClause=false
supports.nestedOlap=true
supports.blobsInGroupBy=false
supports.blobsInOrderBy=false
supports.stitchJoins=false
supports.recursiveWithClause=false
supports.booleanExpressionsInSelectList=false
supports.rowNumberNoOrderBy=true
supports.callProcedureInDerivedTable=false
supports.join.subqueriesInOnClause=false
supports.castClobToVarcharWithoutSubstring=true
supports.subqueriesInGroupBy=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

#
# Performance properties (force certain transformations to be applied). 
#
performance.convertGroupByToDistinct=true

#
# Command.
#

#
# Tables.
#

#
# Constructors.
#
constructors.array=false
constructors.period=false

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

#
# Clauses.
#
clauses.Window=
clauses.WithRecursive=

#
# Joins.
#

#
# Set operators.
#

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

#
# Arithmetic operators.
#
operators.arithmetic.Subtract[any,datetime]=

#
# Group By Operators
#

#
# Comparison predicates.
#

#
# Various predicates.
#
predicates.IsDistinctFrom[any,any]=(%1$s IS NULL AND %2$s IS NOT NULL) OR (%1$s IS NOT NULL AND %2$s IS NULL) OR %1$s <> %2$s
predicates.IsNotDistinctFrom[any,any]=%1$s = %2$s OR (%1$s IS NULL AND %2$s IS NULL)
predicates.Similar=
predicates.Similar.escape=
predicates.LikeRegex=REGEXP_LIKE(%1$s, %2$s)
predicates.LikeRegex.flag=REGEXP_LIKE(%1$s, %2$s, %3$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.
#

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

#
# Cast expression.
#
expressions.Cast[date,timestamp]=timestamp(%1$s,'00:00:00')
expressions.Cast[time,timestamp]=timestamp(CURRENT_DATE, %1$s)
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[timestamp,char]=cast(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF6') as CHAR(%3$d)) 
expressions.Cast[timestamp,varchar]=cast(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF6') as VARCHAR(%3$d)) 
expressions.Cast[text,nchar]=cast((%1$s) as NCHAR(%3$d))
expressions.Cast[text,nvarchar]=cast((%1$s) as NVARCHAR(%3$d))
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,clob]=
expressions.Cast[any,xml]=
expressions.Cast[xml,any]=

#
# Extract expression.
#
expressions.Extract.SECOND[timestamp]=(SECOND(%1$s) + MICROSECOND(%1$s)/1000000.0)
expressions.Extract.SECOND[time]=SECOND(%1$s)
expressions.Extract.TIMEZONE_HOUR[any]=
expressions.Extract.TIMEZONE_MINUTE[any]=
expressions.Extract.EPOCH[any]=

#
# Trim expression.
#

#
# Windowed aggregates (SQL/OLAP).
#
olap.Count[any]=COUNT_BIG(%1$s)
olap.CountStar[]=COUNT_BIG(*)
olap.StdDevPop[any]=
olap.VarPop[any]=
olap.NTile[any]=
olap.Tertile[]=
olap.RatioToReport[any]=
olap.Difference[any]=
olap.Lag[any,any,any,any]=LAG(%1$s, %2$s, %3$s, '%4$s')
olap.Lead[any,any,any,any]=LEAD(%1$s, %2$s, %3$s, '%4$s')
olap.NthValue[any,any,any]=
olap.NthValue[any,any,any,any]=
olap.Collect[any]=

#
# Window clause.
#

#
# Window specification
# A list of windows specifications that are supported by the DB
# P = PARTITION BY
# O = ORDER BY
# F = FRAME 
#
olap.Window.Specification[F]=false
olap.Window.Specification[PF]=false

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

#
# Aggregates.
#
aggregates.Count[any]=COUNT_BIG(%1$s)
aggregates.Count[blob]=COUNT_BIG(CASE WHEN %1$s IS NOT NULL THEN 1 END)
aggregates.CountStar[]=COUNT_BIG(*)
aggregates.StdDevPop[any]=
aggregates.Rank[any,any]=
aggregates.DenseRank[any,any]=
aggregates.VarPop[any]=
aggregates.ArrayAgg[any]=
aggregates.ArrayAgg[any,any]=
aggregates.Collect[any]=
aggregates.ApproxCountDistinct[any]=

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

#
# Linear regression aggregates.
#
aggregates.CovarPop[any,any]=CORRELATION(%1$s, %2$s)
aggregates.CovarSamp[any,any]=

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

#
# Character scalar functions.
#

functions.CharLength[any]=LENGTH(%1$s, CODEUNITS32)
functions.BitLength[any]=(OCTET_LENGTH(%1$s) * 8)
functions.Substring[any,any]=SUBSTRING(%1$s, %2$s, CODEUNITS32)
functions.Substring[any,any,any]=SUBSTRING(%1$s, %2$s, %3$s, CODEUNITS32)
functions.Position[any,any]=POSITION(%1$s, %2$s, CODEUNITS32)
functions.Position[binary,blob]=LOCATE(blob(%1$s), %2$s)
functions.Index[any,any]=POSITION(%2$s, %1$s, CODEUNITS32)
functions.Translate[any,any]=
functions.Normalize[any]=
functions.Normalize[any,any]=
functions.Normalize[any,any,any]=
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[double,any]=CASE WHEN (%1$s) < 0 THEN (CAST( ( (%1$s) * POWER( 10e0, (%2$s) ) - 0.5 ) AS BIGINT ) / POWER( 10e0, (%2$s) ) ) ELSE (CAST( ( (%1$s) * POWER( 10e0, (%2$s) ) + 0.5 ) AS BIGINT ) / POWER( 10e0, (%2$s) ) ) END
functions.Round[float,any]=CASE WHEN (%1$s) < 0 THEN (CAST( ( (%1$s) * POWER( 10e0, (%2$s) ) - 0.5 ) AS BIGINT ) / POWER( 10e0, (%2$s) ) ) ELSE (CAST( ( (%1$s) * POWER( 10e0, (%2$s) ) + 0.5 ) AS BIGINT ) / POWER( 10e0, (%2$s) ) ) END
functions.Round[any,any,any]=

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

#
# Regular expression functions.
#
functions.SubstringRegex[any,any,any,any,any]=
functions.OccurrencesRegex[any,any,any,any]=
functions.PositionRegex[any,any,any,any,any,any]=

#
# FDS functions.
#

functions.cast_longvarchar[any]=CAST(%1$s AS LONG VARCHAR)
functions.cast_longvarchar[time]=CAST(CHAR(%1$s,JIS) AS LONG VARCHAR)

#
# Numeric scalar functions.
#
functions.Abs[interval_day_time]=
functions.Abs[interval_year_month]=

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

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

#
# XML functions.
#
functions.XMLTable=
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[interval_day_time,numeric]=((%1$s) + (%2$s) SECOND)
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.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]=
functions.AddMonths[any,any]=((%1$s) + (%2$s) MONTH)
functions.AddMonths[timestamp_with_time_zone,numeric]=
functions.AddQuarters[any,any]=
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[time,time]=TIMESTAMPDIFF(32, CHAR((TIMESTAMP(CURRENT_DATE, %1$s)-TIMESTAMP(CURRENT_DATE, %2$s)))) 
functions.WeeksBetween[timestamp,timestamp]=TIMESTAMPDIFF(32, CHAR((TIMESTAMP(%1$s)-TIMESTAMP(%2$s))))
functions.MonthsBetween[any,any]=
functions.QuartersBetween[time,time]=TIMESTAMPDIFF(128, CHAR((TIMESTAMP(CURRENT_DATE, %1$s)-TIMESTAMP(CURRENT_DATE, %2$s)))) 
functions.QuartersBetween[timestamp,timestamp]=TIMESTAMPDIFF(128, CHAR((TIMESTAMP(%1$s)-TIMESTAMP(%2$s))))
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]=FIRST_DAY(%1$s)
functions.LastOfMonth[any]=LAST_DAY(%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 ) ) ) )
# Turned off _Months_Between for local processing. This aligns with a hotsite fix in UDA.
functions.WeekOfYear[any]=WEEK_ISO(%1$s)
functions.YMDIntBetween[any,any]=

#
# Table functions.
#

#
# Spatial functions (OpenGIS, SQL/MM).
#
functions.ST_Area[any]=DB2GSE.ST_Area(%1$s)
functions.ST_AsBinary[any]=DB2GSE.ST_AsBinary(%1$s)
functions.ST_AsText[any]=DB2GSE.ST_AsText(%1$s)
functions.ST_Boundary[any]=DB2GSE.ST_Boundary(%1$s)
functions.ST_Buffer[any,any]=DB2GSE.ST_Buffer(%1$s, %2$s)
functions.ST_Centroid[any]=DB2GSE.ST_Centroid(%1$s)
functions.ST_Contains[any,any]=DB2GSE.ST_Contains(%1$s, %2$s)
functions.ST_ConvexHull[any]=DB2GSE.ST_ConvexHull(%1$s)
functions.ST_Crosses[any,any]=DB2GSE.ST_Crosses(%1$s, %2$s)
functions.ST_Dimension[any]=DB2GSE.ST_Dimension(%1$s)
functions.ST_Difference[any,any]=DB2GSE.ST_Difference(%1$s, %2$s)
functions.ST_Disjoint[any,any]=DB2GSE.ST_Disjoint(%1$s, %2$s)
functions.ST_Distance[any,any]=DB2GSE.ST_Distance(%1$s, %2$s)
functions.ST_EndPoint[any]=DB2GSE.ST_EndPoint(%1$s)
functions.ST_Envelope[any]=DB2GSE.ST_Envelope(%1$s)
functions.ST_Equals[any,any]=DB2GSE.ST_Equals(%1$s, %2$s)
functions.ST_ExteriorRing[any]=DB2GSE.ST_ExteriorRing(%1$s)
functions.ST_GeometryN[any,any]=DB2GSE.ST_GeometryN(%1$s, %2$s)
functions.ST_GeometryType[any]=DB2GSE.ST_GeometryType(%1$s)
functions.ST_GeomFromText[any]=DB2GSE.ST_GeomFromText(%1$s)
functions.ST_GeomFromText[any,any]=DB2GSE.ST_GeomFromText(%1$s, %2$s)
functions.ST_InteriorRingN[any,any]=DB2GSE.ST_InteriorRingN(%1$s, %2$s)
functions.ST_Intersection[any,any]=DB2GSE.ST_Intersection(%1$s, %2$s)
functions.ST_Intersects[any,any]=DB2GSE.ST_Intersects(%1$s, %2$s)
functions.ST_IsClosed[any]=DB2GSE.ST_IsClosed(%1$s)
functions.ST_IsEmpty[any]=DB2GSE.ST_IsEmpty(%1$s)
functions.ST_IsRing[any]=DB2GSE.ST_IsRing(%1$s)
functions.ST_IsSimple[any]=DB2GSE.ST_IsSimple(%1$s)
functions.ST_IsValid[any]=DB2GSE.ST_IsSimple(%1$s)
functions.ST_Length[any]=DB2GSE.ST_Length(%1$s)
functions.ST_LineFromText[any]=DB2GSE.ST_LineFromText(%1$s)
functions.ST_LineFromText[any,any]=DB2GSE.ST_LineFromText(%1$s, %2$s)
functions.ST_LineFromWKB[any]=DB2GSE.ST_LineFromWKB(%1$s)
functions.ST_LineFromWKB[any,any]=DB2GSE.ST_LineFromWKB(%1$s, %2$s)
functions.ST_MLineFromText[any]=DB2GSE.ST_MultiLineString(%1$s)
functions.ST_MLineFromText[any,any]=DB2GSE.ST_MultiLineString(%1$s, %2$s)
functions.ST_MLineFromWKB[any]=DB2GSE.ST_MLineFromWKB(%1$s)
functions.ST_MLineFromWKB[any,any]=DB2GSE.ST_MLineFromWKB(%1$s, %2$s)
functions.ST_MPointFromText[any]=DB2GSE.ST_MultiPoint(%1$s)
functions.ST_MPointFromText[any,any]=DB2GSE.ST_MultiPoint(%1$s, %2$s)
functions.ST_MPointFromWKB[any]=DB2GSE.ST_MPointFromWKB(%1$s)
functions.ST_MPointFromWKB[any,any]=DB2GSE.ST_MPointFromWKB(%1$s, %2$s)
functions.ST_MPolyFromText[any]=DB2GSE.ST_MultiPolygon(%1$s)
functions.ST_MPolyFromText[any,any]=DB2GSE.ST_MultiPolygon(%1$s, %2$s)
functions.ST_MPolyFromWKB[any]=DB2GSE.ST_MPolyFromWKB(%1$s)
functions.ST_MPolyFromWKB[any,any]=DB2GSE.ST_MPolyFromWKB(%1$s, %2$s)
functions.ST_NumGeometries[any]=DB2GSE.ST_NumGeometries(%1$s)
functions.ST_NumInteriorRing[any]=DB2GSE.ST_NumInteriorRing(%1$s)
functions.ST_NumPoints[any]=DB2GSE.ST_NumPoints(%1$s)
functions.ST_Overlaps[any,any]=DB2GSE.ST_Overlaps(%1$s, %2$s)
functions.ST_PointFromText[any]=DB2GSE.ST_Point(%1$s)
functions.ST_PointFromText[any,any]=DB2GSE.ST_Point(%1$s, %2$s)
functions.ST_PointFromWKB[any]=DB2GSE.ST_PointFromWKB(%1$s)
functions.ST_PointFromWKB[any,any]=DB2GSE.ST_PointFromWKB(%1$s, %2$s)
functions.ST_PointN[any,any]=DB2GSE.ST_PointN(%1$s, %2$s)
functions.ST_PointOnSurface[any,any]=DB2GSE.ST_PointOnSurface(%1$s)
functions.ST_PolyFromText[any]=DB2GSE.ST_Polygon(%1$s)
functions.ST_PolyFromText[any,any]=DB2GSE.ST_Polygon(%1$s, %2$s)
functions.ST_PolyFromWKB[any]=DB2GSE.ST_PolyFromWKB(%1$s)
functions.ST_PolyFromWKB[any,any]=DB2GSE.ST_PolyFromWKB(%1$s, %2$s)
functions.ST_Relate[any,any]=DB2GSE.ST_Relate(%1$s, %2$s, %3$s)
functions.ST_SRID[any]=DB2GSE.ST_SRID(%1$s)
functions.ST_StartPoint[any]=DB2GSE.ST_StartPoint(%1$s)
functions.ST_SymDifference[any,any]=DB2GSE.ST_SymDifference(%1$s, %2$s)
functions.ST_Touches[any,any]=DB2GSE.ST_Touches(%1$s, %2$s)
functions.ST_Union[any,any]=DB2GSE.ST_Union(%1$s, %2$s)
functions.ST_Within[any,any]=DB2GSE.ST_Within(%1$s, %2$s)
functions.ST_X[any]=DB2GSE.ST_X(%1$s)
functions.ST_Y[any]=DB2GSE.ST_Y(%1$s)

#
# Literals.
# Use datatypes only, not domains.
#
literals.binary=false
literals.boolean=false
literals.time_with_time_zone=false
literals.timestamp_with_time_zone=false
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.xml=false

#
# Literal constraints.
#
literals.time.fractional_seconds=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.date=DATE('%1$04d-%2$02d-%3$02d')
literals.format.time=TIME('%1$02d:%2$02d:%3$02d')
literals.format.time_with_time_zone={t '%1$02d:%2$02d:%3$02d%4$.4s%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={ts '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.10s%10$c%8$02d:%9$02d'}
literals.format.nchar='%s'
literals.format.nvarchar='%s'

#
# Data types.
#
dataType.time_with_time_zone=false
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

#
# Collation sequence query
# collation.sequence.sql=<sql_statement> The query can return only a single result
#
# NOTE:
# The query to db_collname will return one of the following values.
# UNIQUE
# NON_UNIQUE
# The data is ordered using the 256 byte weight table
#
# IDENTITY
# The data is ordered in binary.
#
# IDENTITY_16BIT
# UTF-16 data is ordered in binary. UTF-8 is ordered as if it had been converted to UTF-16 
# and then binary sorted. (IDENTITY and IDENTITY_16BIT are identical except for how supplementary characters in UTF-8 are handled.)
#
# UCA...
# Collations implemented with ICU.
#
# SYSTEM...
# The data is ordered using a 256 character weight table. The specific ordering is detailed in out documentation (search on the collation name).
#
collation.sequence.sql=SELECT CODEPAGE.VALUE || '.' || COLLNAME.VALUE, 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 (SELECT VALUE FROM SYSIBMADM.DBCFG WHERE NAME = 'codepage') CODEPAGE, (SELECT VALUE FROM SYSIBMADM.DBCFG WHERE NAME = 'db_collname') COLLNAME

#
# Collation sequence mappings
# collation.sequence.mapping.<sql_result>=<collation_name>,<collation_weight>
#
# NOTE: These mappings are case sensitive
#
collation.sequence.mapping.1252.UNIQUE=IbmDb2Udb1252Unique,TERTIARY
collation.sequence.mapping.1252.IDENTITY=IbmDb2Udb1252Identity,TERTIARY
collation.sequence.mapping.1208.IDENTITY=UnicodeCodepoint,IDENTICAL

#
# DB2-specific data types that are not defined in the JDBC 3.0 standard
# datasource.type.<datasource specific name>=XQE data type specification
# all spaces need to be replaced with an underscore (_)
#
#datasource.type.DECFLOAT=double
#datasource.type.XML=xml