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

#
#  The configuration of this properties file supports Hive 1x as a base line.
#

#
# Product information.
#

# 
# Delimiters
# 
delimiters.commentBegin=
delimiters.commentEnd=

#
# Keywords.
#

#
# Various limits. A value of 0 means no limit, or the limit is unknown.
#
limits.defaultTransactionIsolation=

#
# General settings.
#

general.nullsAreSortedLow=true
# Until HIVE-15548 is resolved do not enable for Hive 2.1
general.nullsOrdering=false
# Until HIVE-15548 is resolved do not enable for Hive 2.1
general.nullsOrderingInWindowSpecification=false

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

#
# 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.tableCorrelationNames=true
supports.expressionsInOrderBy=false
supports.aliasInOrderByExpression=true
supports.expressionsInINPredicate=true
supports.expressionsInSelectList=true
supports.booleanExpressionsInSelectList=true
supports.fieldsOfComplexTypeInSelectList=false
supports.likeEscapeClause=false
supports.outerJoins=true
supports.fullOuterJoins=true
#hive supports sub queries only in FROM clause
supports.subqueriesInComparisons=false
supports.subqueriesInExists=false
supports.subqueriesInIns=false
supports.subqueriesInQuantifieds=false
supports.subqueriesInCase=false
supports.correlatedSubqueries=false
supports.correlatedSubqueriesInSelectList=false
supports.correlatedSubqueriesInIns=false
supports.withClauseInDerivedTable=false
supports.nestedWithClause=false
supports.integerDivision=false
supports.groupedWindowedTables=false
supports.derivedColumnLists=false
supports.orderByOrdinal=false
#hive supports sub queries only in FROM clause
supports.scalarSubqueries=false
supports.expressionsInGroupBy=true
supports.equiJoins=true
supports.thetaJoins=false
supports.stitchJoins=false
supports.crossProducts=true
supports.recursiveWithClause=false
supports.orderByUnrelated=false
supports.groupByUnrelated=false
supports.constantsInWindows=true
supports.callProcedureInDerivedTable=false
supports.join.orInOnClause=false
supports.join.subqueriesInOnClause=false
supports.join.onlyEquiWithAnd=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.join.inner.limitedThetaJoins=true

#
# Performance properties (force certain transformations to be applied). 
#


#
# Command.
#
commands.Call=

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

#
# Constructors.
#
constructors.table=false
constructors.row=false
constructors.array=false
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
clauses.With=WITH
clauses.OrderBy=ORDER BY
clauses.Distinct=DISTINCT
clauses.Top=
clauses.FetchFirst=
clauses.At=
clauses.Window=
clauses.WithRecursive=
clauses.Limit=LIMIT %1$s
clauses.TableSampleSystem=
clauses.TableSampleBernoulli=
clauses.ForSystemTimeAsOf=
clauses.ForSystemTimeFrom=
clauses.ForSystemTimeBetween=

#
# Joins.
#
# Join condition does not support OR clause
# Does not support non-equi joins
# Does not allow on condition to use set functions
# Does not allow join conditions to use sub-queries
# Does not allow non equi joins in full outer join
# Only allows equal with and conditions in joins
# Does not support outer non-equi joins
#
# Nested joins may fail in Hive 1.2x when vectorization is enabled APACHE JIRA HIVE-11371
joins.Cross=%1$s CROSS JOIN %2$s
joins.Inner=%1$s 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.
#

# Apachive Hive HIVE-10487 requires the projections to have identical names unlike ISO-SQL 
operators.set.Union=
operators.set.Union.all=
#operators.set.Union.all=%1$s UNION ALL %2$s
operators.set.Intersect=
operators.set.Intersect.all=
operators.set.Except=
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 operators.
#
# For Hive concat has below format. Rest all arithmetic operators remains as in SQL.properties.

# 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.Subtract[date,any]= 
operators.arithmetic.Subtract[any,date]= 
operators.arithmetic.Subtract[timestamp,any]= 
operators.arithmetic.Subtract[any,timestamp]= 

#
# Group By Operators
#
operators.groupBy.Rollup=
operators.groupBy.Cube=
operators.groupBy.GroupingSets=

#
# Comparison predicates.
#

#
# Various predicates.
#
# Note in Hive 1.2x if vectorization is left on this may fail 
# APACHE JIRA HIVE-11372
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=
predicates.Like.escape=
predicates.LikeRegex=
predicates.LikeRegex.flag=
predicates.Similar=
predicates.Similar.escape=
##Hive does not support EXISTS in where clause. 
predicates.Exists=
predicates.All=
predicates.Any=
predicates.Some=
predicates.IsDistinctFrom[any,any]=
predicates.IsNotDistinctFrom[any,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.
#
expressions.ArrayElementRef.zeroBased=false
expressions.SimpleCase=CASE
expressions.SearchedCase=CASE
# 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
# APACHE JIRA HIVE-15552 will result in an error for coalesce or case expression mixing DATE and TIMESTAMPS 
expressions.Coalesce.minArgs=2


#
# Cast expression.
#
expressions.Cast[any,integer]=CAST(%1$s AS int)
expressions.Cast[smallint,long]=
expressions.Cast[smallint,float]=
expressions.Cast[any,double]=CAST(%1$s AS double)
expressions.Cast[any,varchar]=
expressions.Cast[integer,smallint]=
expressions.Cast[integer,integer]=
expressions.Cast[integer,long]=
expressions.Cast[integer,float]=
expressions.Cast[integer,double]=
expressions.Cast[long,smallint]=
expressions.Cast[long,integer]=
expressions.Cast[long,float]=
expressions.Cast[long,double]=
expressions.Cast[decimal,text]=
expressions.Cast[float,smallint]=
expressions.Cast[float,integer]=
expressions.Cast[float,long]=
expressions.Cast[float,double]=
expressions.Cast[float,text]=
expressions.Cast[double,smallint]=
expressions.Cast[double,integer]=
expressions.Cast[double,long]=
expressions.Cast[double,float]=
expressions.Cast[double,double]=
expressions.Cast[double,text]=
expressions.Cast[varchar,smallint]=
expressions.Cast[varchar,integer]=
expressions.Cast[varchar,long]=
expressions.Cast[varchar,float]=
expressions.Cast[varchar,double]=
expressions.Cast[varchar,timestamp]=
# Hive does not support timestamps with up to 9 digits of precision attempting to cast a character literal or value 
# expression to a timestamp will loose fractional seconds.

#expressions.Cast[timestamp,text]=

#
# Extract expression.
#
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)
expressions.Extract.TIMEZONE_HOUR[any]=
expressions.Extract.TIMEZONE_MINUTE[any]=
expressions.Extract.EPOCH[any]=

#
# Trim expression.
#
expressions.Trim.BOTH[any]=trim(%1$s)
expressions.Trim.BOTH[any,any]=
expressions.Trim.LEADING[any]=ltrim(%1$s)
expressions.Trim.LEADING[any,any]=
expressions.Trim.TRAILING[any]=rtrim(%1$s)
expressions.Trim.TRAILING[any,any]=

#
# Windowed aggregates (SQL/OLAP).
#

# Hive 2.1 fails if the input to the aggregate is a standard aggregate HIVE-15553
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.Count[any]=COUNT(%1$s)
olap.CountStar[]=COUNT(*)
olap.CumeDist[]=CUME_DIST()
olap.StdDevSamp[any]=
olap.StdDevPop[any]=
olap.VarSamp[any]=
olap.VarPop[any]=
olap.Rank[]=RANK()
olap.DenseRank[]=DENSE_RANK()
olap.PercentRank[]=PERCENT_RANK()
olap.PercentileCont[any,any]=
olap.PercentileDisc[any,any]=
olap.Median[any]=
olap.RowNumber[]=ROW_NUMBER()
olap.FirstValue[any]=FIRST_VALUE(%1$s)
olap.NTile[any]=
olap.Tertile[]=
olap.RatioToReport[any]=
olap.Difference[any]=
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.LastValue[any]=LAST_VALUE(%1$s)
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.Window=
olap.PartitionBy=PARTITION BY %1$s
olap.OrderBy=ORDER BY %1$s

# 
# Window specification
# 
# Older Hive 1.x releases had various issues 
# https://issues.apache.org/jira/browse/HIVE-4663
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).
#
# Note - Hive 2.1 will impose the following restriction
# Current implementation has the limitation that no ORDER BY or window specification can be supported in the partitioning clause for performance reasons
#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)
olap.Min.distinct[any]=
olap.Max.distinct[any]=
olap.Sum.distinct[any]=
olap.Avg.distinct[any]=
olap.Count.distinct[any]=

#
# Aggregates.
#
aggregates.Min[text]=
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.PercentileCont[any,any]=
aggregates.PercentileDisc[any,any]=
aggregates.Median[any]=
aggregates.XMLAgg=
aggregates.Grouping[any]=
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.
#
# APACHE JIRA HIVE-9537
functions.CharLength[char]=
functions.CharLength[any]=LENGTH(%1$s)
functions.CharLength[clob]=
functions.OctetLength[text]=
functions.BitLength[text]=
# note that Hive will return a char as a varchar with trailing spaces removed
# APACHE JIRA HIVE-9537
functions.Upper[char]=
functions.Upper[any]=UPPER(%1$s)
# note that Hive will return a char as a varchar with trailing spaces removed
# APACHE JIRA HIVE-9537
functions.Lower[char]=
functions.Lower[any]=LOWER(%1$s)
# hive will return nothing if a char field was spaces
# APACHE JIRA HIVE-9537
functions.Substring[char,any]=
functions.Substring[any,any]=substr(%1$s, cast(%2$s as int))
# hive will return nothing if a char field was spaces
# APACHE JIRA HIVE-9537
functions.Substring[char,any,any]=
# hive has copied mysql hence if position is negative they start from the end versus how ISO-SQL
# typical cases using ISO-SQL substring do not use a negative start position. 
# APACHE JIRA HIVE-10282
functions.Substring[any,any,any]=substr(%1$s, cast(%2$s as int), cast(%3$s as int))
functions.Position[any,any]=locate(%2$s, %1$s)
functions.Index[any,any]=
functions.Ascii[any]=
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]=

# 
# 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)
functions.Ln[any]=LN(%1$s)
functions.Log10[any]=LOG10(%1$s)
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.Sign[any]=SIGN(%1$s)
functions.Sqrt[any]=SQRT(%1$s)
## mod function is not supported by Hive. Instead PMOD is supported which returns +ive value of a Mod b.
functions.Mod[any,any]=
##function round with 3 parameters not supported by Hive.
functions.Round[any,any,any]=
##function WidthBucket not supported by Hive.
functions.WidthBucket[any,any,any,any]=

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

#
# Trigonometric functions.
#
functions.Arccos[any]=ACOS(%1$s)
functions.Cos[any]=COS(%1$s)
functions.Arcsin[any]=ASIN(%1$s)
functions.Sin[any]=SIN(%1$s)
functions.Arctan[any]=ATAN(%1$s)
functions.Tan[any]=TAN(%1$s)
## COSHYP not supported by Hive.
functions.Coshyp[any]=
## SINHYP not supported by Hive.
functions.Sinhyp[any]=
## TANHYP not supported by Hive.
functions.Tanhyp[any]=

#Substring function to negative START value to parse the input string from its rightmost end.
functions.SubstringR[any,any]=
functions.SubstringR[any,any,any]=


#
# Datetime value functions.
#
functions.CurrentDate[]=cast(to_date(cast(from_unixtime( unix_timestamp()) as timestamp)) as date)
functions.CurrentTime[]=
# APACHE JIRA HIVE-11377
functions.CurrentTimestamp[]=
functions.LocalTime[]=
functions.LocalTimestamp[]=cast(from_unixtime( unix_timestamp()) as timestamp)
functions.CurrentTime[numeric]=
functions.CurrentTimestamp[numeric]=
functions.LocalTime[numeric]=
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]=cast(cast(%1$s as double ) + %2$s as timestamp)
functions.AddSeconds[any,any]=cast(cast(%1$s as double ) + cast( %2$s as int) as timestamp)
functions.AddMinutes[any,any]=cast(cast(%1$s as double ) + (60 * cast( %2$s as int)) as timestamp)
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)
# Hive truncates time component of a timestamp if date_add is used
# Apache JIRA HIVE-3196
functions.AddDays[timestamp,numeric]=cast(cast(%1$s as double ) + (86400 * cast( %2$s as int)) as timestamp)
functions.AddWeeks[date,numeric]=cast(date_add(%1$s, cast(%2$s as int) * 7) as date)
# Hive truncates time component of a timestamp if date_add is used
# Apache JIRA HIVE-3196
functions.AddWeeks[timestamp,numeric]=cast(cast(%1$s as double ) + (604800 * cast( %2$s as int)) as timestamp)
functions.AddMonths[any,any]=
functions.AddQuarters[any,any]=
functions.AddYears[date,numeric]=cast(date_add(%1$s, cast(%2$s as int) * 365) as date)
# Hive truncates time component of a timestamp if date_add is used
# Apache JIRA HIVE-3196
functions.AddYears[timestamp,numeric]=
functions.MinutesBetween[any,any]=cast((unix_timestamp( %1$s ) - unix_timestamp( %2$s)) / 60 as bigint)
functions.FractionalSecondsBetween[any,any]=
functions.SecondsBetween[any,any]=(unix_timestamp( %1$s ) - unix_timestamp( %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]=
functions.MonthsBetween[any,any]=
functions.QuartersBetween[any,any]=
functions.YearsBetween[any,any]=
functions.DaysToEndOfMonth[any]=
functions.Age[any]=
functions.FirstOfMonth[any]=
#FirstOfMonth does not work with Julian Calender for Hive 3.1. Defect 278152
functions.FirstOfMonth[date]=cast(date_add( %1$s, (day( %1$s ) - 1) * -1) as date) 
functions.LastOfMonth[any]=
functions.MakeTimestamp[any,any,any]=
functions.DayOfYear[any]=
functions.DayOfWeek[any,any]=
functions.WeekOfYear[any]=weekofyear(%1$s)
functions.YMDIntBetween[any,any]=

#
# Table functions.
#
functions.Unnest=

#
# FDS functions.
#
functions.cast_smallint[any]=
functions.cast_integer[any]=
functions.cast_float[any]=
functions.cast_real[any]=
functions.cast_double[any]=
functions.cast_double_precision[any]=
functions.cast_decimal[any]=
functions.cast_decimal[any,any]=
functions.cast_decimal[any,any,any]=
functions.cast_numeric[any]=
functions.cast_numeric[any,any]=
functions.cast_numeric[any,any,any]=
functions.cast_date[any]=
functions.cast_time[any]=
functions.cast_timestamp[any]=
functions.cast_char[any]=
functions.cast_char[any,any]=
functions.cast_varchar[any]=
functions.cast_varchar[any,any]=

#
# Literals.
#
literals.binary=false
literals.boolean=false
literals.date=true
literals.time=false
literals.time_with_time_zone=false
literals.timestamp=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.decimal=false
literals.char=true
literals.nchar=false
literals.nvarchar=false
literals.xml=false
literals.distinct=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=TIME '%1$02d:%2$02d:%2$02d%4$.10s'
literals.format.time_with_time_zone=TIME '%1$02d:%2$02d:%2$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'

#
# Data types.
#
dataType.binary=false
dataType.blob=false
dataType.clob=false
dataType.date=true
dataType.time=false
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
dataType.decimal=false
dataType.char=true
dataType.nchar=false
dataType.nvarchar=false
dataType.xml=false
dataType.period=false
dataType.array=false
dataType.struct=false
dataType.map=false
dataType.json=false

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

#
# Support for SQL data types that are not defined in the JDBC 3.0 standard
# datasource.type.<datasource specific name>=CCL datatype name
# all spaces need to be replaced with an underscore (_)
#
datasource.type.string=varchar(2048)