# Licensed Materials - Property of IBM
# IBM Cognos Products: OQP
# (C) Copyright IBM Corp. 2005, 2021
# 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=4096

#
# 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.subqueriesInCase=false
supports.subqueriesInAggregate=false
supports.withClauseInDerivedTable=false
supports.nestedWithClause=false
supports.expressionsInOrderBy=true
supports.aliasInOrderByExpression=false
supports.nestedOlap=false
supports.blobsInGroupBy=false
supports.blobsInOrderBy=false
supports.stitchJoins=false
supports.recursiveWithClause=false
supports.booleanExpressionsInSelectList=false
supports.callProcedureInDerivedTable=false
supports.join.full.distinctJoins=false
supports.join.subqueriesInOnClause=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 
#
performance.convertGroupByToDistinct=true

#
# Command.
#

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

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

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

#
# Clauses.
#
clauses.Window=
clauses.WithRecursive=
clauses.TableSampleSystem=
clauses.TableSampleBernoulli=

#
# Joins.
#
#joins.Cross=%2$s CROSS JOIN %1$s
joins.Cross=
#
# Set operators.
#
operators.set.Intersect=
operators.set.Intersect.all=


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

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


#
# Group By Operators
#

operators.groupBy.Rollup=
operators.groupBy.Cube=
operators.groupBy.GroupingSets=

#
# Comparison predicates.
#
predicates.comparison.LessThan[timestamp,date]=
predicates.comparison.LessThan[date,timestamp]=
predicates.comparison.LessThan[timestamp_with_time_zone,date]=
predicates.comparison.LessThan[date,timestamp_with_time_zone]=
predicates.comparison.LessThan[any,clob]=
predicates.comparison.LessThan[clob,any]=
predicates.comparison.LessThanOrEquals[date,timestamp]=
predicates.comparison.LessThanOrEquals[timestamp,date]=
predicates.comparison.LessThanOrEquals[date,timestamp_with_time_zone]=
predicates.comparison.LessThanOrEquals[timestamp_with_time_zone,date]=
predicates.comparison.LessThanOrEquals[any,clob]=
predicates.comparison.LessThanOrEquals[clob,any]=
predicates.comparison.Equals[date,timestamp]=
predicates.comparison.Equals[timestamp,date]=
predicates.comparison.Equals[date,timestamp_with_time_zone]=
predicates.comparison.Equals[timestamp_with_time_zone,date]=
predicates.comparison.Equals[any,clob]=
predicates.comparison.Equals[clob,any]=
predicates.comparison.NotEquals[date,timestamp]=
predicates.comparison.NotEquals[timestamp,date]=
predicates.comparison.NotEquals[date,timestamp_with_time_zone]=
predicates.comparison.NotEquals[timestamp_with_time_zone,date]=
predicates.comparison.NotEquals[any,clob]=
predicates.comparison.NotEquals[clob,any]=
predicates.comparison.GreaterThan[date,timestamp]=
predicates.comparison.GreaterThan[timestamp,date]=
predicates.comparison.GreaterThan[date,timestamp_with_time_zone]=
predicates.comparison.GreaterThan[timestamp_with_time_zone,date]=
predicates.comparison.GreaterThan[any,clob]=
predicates.comparison.GreaterThan[clob,any]=
predicates.comparison.GreaterThanOrEquals[date,timestamp]=
predicates.comparison.GreaterThanOrEquals[timestamp,date]=
predicates.comparison.GreaterThanOrEquals[date,timestamp_with_time_zone]=
predicates.comparison.GreaterThanOrEquals[timestamp_with_time_zone,date]=
predicates.comparison.GreaterThanOrEquals[any,clob]=
predicates.comparison.GreaterThanOrEquals[clob,any]=

#
# Various predicates.
#
predicates.Overlaps[any,any,any,any]=

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.IsDistinctFrom[blob,any]=
predicates.IsDistinctFrom[any,blob]=

predicates.IsNotDistinctFrom[any,any]=%1$s = %2$s OR (%1$s IS NULL AND %2$s IS NULL)
predicates.IsNotDistinctFrom[any,blob]=
predicates.IsNotDistinctFrom[blob,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.Between[date,timestamp_with_time_zone,any]=
predicates.Between[date,any,timestamp_with_time_zone]=
predicates.Between[timestamp_with_time_zone,date,any]=
predicates.Between[timestamp_with_time_zone,any,date]=
predicates.In[date,timestamp]=
predicates.In[date,timestamp_with_time_zone]=
predicates.In[timestamp,date]=
predicates.In[timestamp_with_time_zone,date]=
predicates.In[any,clob]=
predicates.In[clob,any]=

#
# 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.
#
#
# Cast expression.
#
expressions.Cast[date,timestamp]=timestamp(%1$s, '00:00:00')
expressions.Cast[date,timestamp_with_time_zone]=
expressions.Cast[time,timestamp]=timestamp(CURRENT_DATE, %1$s)
expressions.Cast[time,timestamp_with_time_zone]=
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[timestamp_with_time_zone,varchar]=cast(TO_CHAR(%1$s, 'YYYY-MM-DD HH24:MI:SS.FF6TZH:TZM') as VARCHAR(%3$d)) 
expressions.Cast[timestamp_with_time_zone,char]=cast(TO_CHAR(%1$s, 'YYYY-MM-DD HH24:MI:SS.FF6TZH:TZM') as CHAR(%3$d)) 
expressions.Cast[text,nchar]=
expressions.Cast[text,nvarchar]=
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[timestamp_with_time_zone,nvarchar]=cast(TO_CHAR(%1$s, 'YYYY-MM-DD HH24:MI:SS.FF6TZH:TZM') as VARCHAR(%3$d)) 
expressions.Cast[timestamp_with_time_zone,nchar]=cast(TO_CHAR(%1$s, 'YYYY-MM-DD HH24:MI:SS.FF6TZH:TZM') as CHAR(%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[numeric,clob]=cast(cast(%1$s as varchar(64)) as clob)
expressions.Cast[datetime,clob]=cast(cast(%1$s as varchar(38)) as clob)
expressions.Cast[xml,any]=
#DB2/zOs requires space between the precision and scale if set zparm decimal=comma 
expressions.Cast[any,decimal]=CAST(%1$s AS DECIMAL(%3$d, %4$d))
expressions.Cast[any,xml]=

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

#
# Extract expression.
#
expressions.Extract.EPOCH[any]=

#
# Trim expression.
#
expressions.Trim.BOTH[any]=LTRIM(RTRIM(%1$s))
expressions.Trim.LEADING[any]=LTRIM(%1$s)
expressions.Trim.TRAILING[any]=RTRIM(%1$s)
expressions.Trim.BOTH[any,any]=STRIP(%2$s, B, %1$s)
expressions.Trim.LEADING[any,any]=STRIP(%2$s, L, %1$s)
expressions.Trim.TRAILING[any,any]=STRIP(%2$s, T, %1$s)

#
# Windowed aggregates (SQL/OLAP).
#

olap.Count[any]=COUNT_BIG(%1$s)
olap.CountStar[]=COUNT_BIG(*)
olap.Count[clob]=COUNT(CASE WHEN %1$s IS NOT NULL THEN 1 END)
olap.Count[blob]=COUNT(CASE WHEN %1$s IS NOT NULL THEN 1 END)
olap.StdDevSamp[any]=
olap.VarSamp[any]=
olap.VarPop[any]=VARIANCE(%1$s)
olap.PercentRank[]=
olap.CumeDist[]=
olap.PercentileCont[any,any]=
olap.PercentileDisc[any,any]=
olap.Median[any]=
olap.NTile[any]=
olap.Tertile[]=
olap.RatioToReport[any]=
olap.Difference[any]=
olap.FirstValue[any]=
olap.LastValue[any]=
olap.Lag[any]=
olap.Lag[any,any]=
olap.Lag[any,any,any]=
olap.Lag[any,any,any,any]=
olap.Lead[any]=
olap.Lead[any,any]=
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.
#


#
# 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.Max.distinct[any]=
olap.Min.distinct[any]=
olap.Sum.distinct[any]=
olap.Avg.distinct[any]=
olap.Count.distinct[any]=

#
# Aggregates.
#
aggregates.Count[any]=COUNT_BIG(%1$s)
aggregates.CountStar[]=COUNT_BIG(*)
aggregates.Count[clob]=COUNT_BIG(CASE WHEN %1$s IS NOT NULL THEN 1 END)
aggregates.Count[blob]=COUNT_BIG(CASE WHEN %1$s IS NOT NULL THEN 1 END)
aggregates.PercentRank[any,any]=
aggregates.CumeDistH[any,any]=
aggregates.Median[any]=
aggregates.VarSamp[any]=VARIANCE_SAMP(%1$s)
aggregates.VarPop[any]=VARIANCE(%1$s)
aggregates.ArrayAgg[any]=
aggregates.ArrayAgg[any,any]=
aggregates.Collect[any]=
aggregates.ApproxCountDistinct[any]=

#
# Aggregates (distinct).
#

#
# 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]=(CHARACTER_LENGTH(%1$s, OCTETS)*8)
functions.OctetLength[any]=CHARACTER_LENGTH(%1$s, OCTETS)
functions.Upper[clob]=
functions.Lower[clob]=
functions.Substring[any,any]=SUBSTR(%1$s, %2$s)
functions.Substring[any,any,any]=SUBSTR(%1$s, %2$s, %3$s)
functions.Position[any,any]=POSSTR(%2$s, %1$s)
functions.Index[any,any]=POSSTR(%1$s, %2$s)
functions.Translate[any,any]=
functions.Normalize[any]=
functions.Normalize[any,any]=
functions.Normalize[any,any,any]=

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

#
# FDS functions.
#

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

#
# Numeric scalar functions.
#
functions.Abs[interval_day_time]=
functions.Abs[interval_year_month]=
functions.WidthBucket[any,any,any,any]=
functions.Mod[decimal,any]=MOD(INTEGER(%1$s), %2$s)
functions.Random[]=RAND()
functions.Random[any]=RAND(%1$s)
#
# 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[any,any]=
functions.AddHours[interval_day_time,numeric]=((%1$s) + (%2$s) HOUR)
functions.AddHours[time,numeric]=((%1$s) + (%2$s) HOUR)
functions.AddHours[timestamp,numeric]=(TIMESTAMP(%1$s) + (%2$s) HOUR)
functions.AddHours[time_with_time_zone,numeric]=((%1$s) + (%2$s) HOUR)
functions.AddHours[timestamp_with_time_zone,numeric]=((%1$s) + (%2$s) HOUR)
functions.AddMinutes[interval_day_time,numeric]=((%1$s) + (%2$s) MINUTE)
functions.AddMinutes[time,numeric]=((%1$s) + (%2$s) MINUTE)
functions.AddMinutes[timestamp,numeric]=(TIMESTAMP(%1$s) + (%2$s) MINUTE)
functions.AddMinutes[time_with_time_zone,numeric]=((%1$s) + (%2$s) MINUTE)
functions.AddMinutes[timestamp_with_time_zone,numeric]=((%1$s) + (%2$s) MINUTE)
functions.AddDays[numeric,any]=
functions.AddDays[datetime,any]=((%1$s) + (%2$s) DAY)
functions.AddWeeks[any,any]=
functions.AddMonths[numeric,any]=
functions.AddMonths[datetime,any]=((%1$s) + (%2$s) MONTH)
functions.AddQuarters[any,any]=
functions.AddYears[numeric,any]=
functions.AddYears[datetime,any]=((%1$s) + (%2$s) YEAR)
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))))
# Turned off _Months_Between for local processing. This alignes with a hotsite fix in UDA.
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,timestamp_with_time_zone]=
functions.YearsBetween[timestamp_with_time_zone,date]=
functions.YearsBetween[date,date]=TIMESTAMPDIFF(256, char(TIMESTAMP(%1$s, '00:00:00') - TIMESTAMP(%2$s, '00:00:00')))
functions.Age[timestamp]=(CURRENT DATE - DATE(%1$s))
functions.Age[timestamp_with_time_zone]=(CURRENT DATE - DATE(%1$s))
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.MakeTimestamp[any,any,any]=TIMESTAMP_ISO(DATE(CHAR(RIGHT(DIGITS(%1$s), 4) || '-' || RIGHT(DIGITS(%2$s), 2) || '-' || RIGHT(DIGITS(%3$s), 2))))
functions.WeekOfYear[any]=WEEK_ISO(%1$s)
functions.YMDIntBetween[any,any]=

#
# Table functions.
#

#
# Spatial functions (OpenGIS, SQL/MM).
#

#
# Literals.
#
literals.binary=true
literals.blob=false
literals.clob=false
literals.boolean=false
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

#
# Literal constraints.
#

#
# 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.binary=BINARY(X'%1$s')
literals.format.date=DATE('%1$04d-%2$02d-%3$02d') 
literals.format.interval_day=%3$s%1$d DAY
literals.format.interval_month=%3$s%1$d MONTH
literals.format.interval_year=%3$s%1$d YEAR
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=TIMESTAMP '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.7s%10$c%8$02d:%9$02d'
literals.format.nchar='%s'
literals.format.nvarchar='%s'

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

#datasource.type.TIMESTAMP_WITH_TIME_ZONE=timestamp with time zone
#datasource.type.timestamp_with_time_zone.separator=\\b
#datasource.type.timestamp_with_time_zone.mapping=%1$s%2$s%3$s%4$s%5$s%6$s %8$s:%10$s:%12$s%13$s%14$s%15$s%16$s%17$s%18$s
#datasource.type.REAL=double