analytics/configuration/xqe/sqlserver.properties

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

#
# Product information.
#

#
# Delimiters.
#

#
# Various limits.
#
limits.castClobToVarcharMaxSize=8000
limits.maxDecimalPrecision=38

#
# General settings.
#
general.nullsAreSortedLow=true
general.nullsOrdering=false
general.nullsOrderingInWindowSpecification=false

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

#
# Various features.
#
supports.sqlserverWindowBehaviour=true
supports.withClauseInDerivedTable=false
supports.nestedWithClause=false
supports.blobsInGroupBy=false
supports.blobsInOrderBy=false
supports.mixedCaseIdentifiers=false
supports.mixedCaseQuotedIdentifiers=false
supports.charLiteralRoundTrip=false
supports.stitchJoins=false
supports.expressionsInGroupBy=false
supports.subqueriesInAggregate=false
supports.recursiveWithClause=false
supports.booleanExpressionsInSelectList=false
supports.aliasInOrderByExpression=false
supports.orderByInDerivedTable=false
supports.callProcedureInDerivedTable=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

#
# Command.
#

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

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

#
# Clauses.
#
clauses.Top=TOP %1$s
clauses.Top.Position=distinct.top
clauses.At=
clauses.Window=
clauses.WithRecursive=
clauses.TableSampleSystem=TABLESAMPLE SYSTEM (%1$s PERCENT)@2[ REPEATABLE (%2$s)]
clauses.TableSampleBernoulli=

#
# Joins.
#

#
# Set operators.
#
operators.set.Intersect.all=
operators.set.Except.all=

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

#
# Arithmetic operators.
#
operators.arithmetic.Subtract[any,datetime]=
operators.arithmetic.Concat[any,any]=(%1$s + %2$s)
operators.arithmetic.Concat[clob,clob]=
operators.arithmetic.Concat[text,clob]=
operators.arithmetic.Concat[clob,text]=

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

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

#
# Various predicates.
#
predicates.In[clob,any]=
predicates.In[any,clob]=
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=

#
# 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,char]=CAST(CONVERT(CHAR(10), %1$s, 121) AS %2$s)
expressions.Cast[date,varchar]=CAST(CONVERT(CHAR(10), %1$s, 121) AS %2$s)
expressions.Cast[date,nchar]=CAST(CONVERT(NCHAR(10), %1$s, 121) AS %2$s)
expressions.Cast[date,nvarchar]=CAST(CONVERT(NCHAR(10), %1$s, 121) AS %2$s)
expressions.Cast[date,date]=CAST( (%1$s) AS DATE )
expressions.Cast[any,clob]=CAST(%1$s as TEXT)
expressions.Cast[numeric,clob]=
expressions.Cast[time,char]=CAST(CONVERT(CHAR(12),%1$s, 114) AS %2$s)
expressions.Cast[time,varchar]=CAST(CONVERT(CHAR(12), %1$s, 114) AS %2$s)
expressions.Cast[time,nchar]=CAST(CONVERT(NCHAR(10), %1$s, 121) AS %2$s)
expressions.Cast[time,nvarchar]=CAST(CONVERT(NCHAR(10), %1$s, 121) AS %2$s)
expressions.Cast[time,time]=CAST( (%1$s) AS TIME )
expressions.Cast[time,text]=
expressions.Cast[timestamp,text]=CONVERT(%2$s, %1$s, 121) 
expressions.Cast[any,float]=CAST(%1$s AS REAL)
expressions.Cast[date,timestamp]=CAST(%1$s as DATETIME)
expressions.Cast[null,timestamp]=CAST(%1$s as DATETIME)
expressions.Cast[time,timestamp]=
expressions.Cast[any,timestamp_with_time_zone]=CAST(%1$s as DATETIMEOFFSET)
expressions.Cast[any,timestamp]=CAST(%1$s as DATETIME)
# DB uses wrong timezone when convert time time timestamp TZ
expressions.Cast[time,timestamp_with_time_zone]=
expressions.Cast[timestamp,timestamp]=CAST(%1$s as DATETIME)
expressions.Cast[timestamp,char]=CAST(CONVERT(CHAR(30),%1$s, 121) AS %2$s)
expressions.Cast[timestamp_with_time_zone,timestamp_with_time_zone]=%1$s
expressions.Cast[timestamp_with_time_zone,char]=CONVERT( %2$s, %1$s, 121 )
expressions.Cast[timestamp_with_time_zone,varchar]=CONVERT( %2$s, %1$s, 121 )
expressions.Cast[timestamp_with_time_zone,nchar]=CONVERT( %2$s, %1$s, 121 )
expressions.Cast[timestamp_with_time_zone,nvarchar]=CONVERT( NVARCHAR%2$s, %1$s, 121 )
expressions.Cast[timestamp_with_time_zone,timestamp]=
expressions.Cast[char,timestamp]=CAST(%1$s as DATETIME)
expressions.Cast[nchar,timestamp]=CAST(%1$s as DATETIME)
expressions.Cast[nvarchar,timestamp]=CAST(%1$s as DATETIME)
expressions.Cast[varchar,timestamp]=CAST(%1$s as DATETIME)
#expressions.Cast[clob,varchar]=CONVERT(varchar(max), %1$s)
expressions.Cast[clob,char]=CAST(%1$s AS %2$s)
expressions.Cast[clob,nchar]=CAST(%1$s AS %2$s)
expressions.Cast[clob,varchar]=CAST(%1$s as VARCHAR(MAX))
expressions.Cast[clob,any]=

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

#
# Extract expression.
#
expressions.Extract.YEAR[any]=DATEPART(YEAR, %1$s)
expressions.Extract.MONTH[any]=DATEPART(MONTH, %1$s)
expressions.Extract.DAY[any]=DATEPART(DAY, %1$s)
expressions.Extract.HOUR[any]=DATEPART(HOUR, %1$s)
expressions.Extract.MINUTE[any]=DATEPART(MINUTE, %1$s)
expressions.Extract.SECOND[any]=(DATEPART(SECOND, %1$s) + (CAST(DATEPART(MILLISECOND, %1$s) as DECIMAL) / 1000))
expressions.Extract.TIMEZONE_HOUR[any]=DATEPART(TZOFFSET, %1$s) / 60
expressions.Extract.TIMEZONE_MINUTE[any]=DATEPART(TZOFFSET, %1$s) %% 60
expressions.Extract.EPOCH[any]=

#
# Trim expression.
#
expressions.Trim.BOTH[any]=LTRIM(RTRIM(%1$s))
expressions.Trim.BOTH[clob]=
expressions.Trim.LEADING[any]=LTRIM(%1$s)
expressions.Trim.LEADING[clob]=
expressions.Trim.TRAILING[any]=RTRIM(%1$s)
expressions.Trim.TRAILING[clob]=
expressions.Trim.BOTH[any,any]=
expressions.Trim.LEADING[any,any]=
expressions.Trim.TRAILING[any,any]=

#
# Windowed aggregates (SQL/OLAP).
#
olap.Count[any]=COUNT_BIG(%1$s)
olap.CountStar[]=COUNT_BIG(*)
olap.Count[blob]=COUNT_BIG(CASE WHEN %1$s IS NOT NULL THEN 1 END)
olap.StdDevSamp[any]=STDEV(%1$s)
olap.StdDevPop[any]=STDEVP(%1$s)
olap.VarSamp[any]=VAR(%1$s)
olap.VarPop[any]=VARP(%1$s)
olap.Tertile[]=
olap.RatioToReport[any]=
olap.Difference[any]=
olap.Lag[any,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]=
olap.Median[any]=PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY %1$s)

#
# Window clause.
#

#
# Window specification
# A list of windows specifications that are supported by the DB
# P = PARTITION BY
# O = ORDER BY
# F = FRAME 
#

#
# 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.Count[blob]=COUNT_BIG(CASE WHEN %1$s IS NOT NULL THEN 1 END)
aggregates.CountStar[]=COUNT_BIG(*)
aggregates.StdDevSamp[any]=STDEV(%1$s)
aggregates.StdDevPop[any]=STDEVP(%1$s)
aggregates.VarSamp[any]=VAR(%1$s)
aggregates.VarPop[any]=VARP(%1$s)
aggregates.CumeDistH[any,any]=
aggregates.PercentileCont[any,any]=
aggregates.PercentileDisc[any,any]=
aggregates.Median[any]=
aggregates.XMLAgg=
aggregates.ArrayAgg[any]=
aggregates.ArrayAgg[any,any]=
aggregates.Collect[any]=
aggregates.ApproxCountDistinct[any]=

#
# Aggregates (distinct).
#
aggregates.Count.distinct[any]=COUNT_BIG(DISTINCT %1$s)
aggregates.Count.distinct[blob]=

#
# 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]=LEN(%1$s)
functions.CharLength[char]=LEN(REPLACE(%1$s, ' ', 'x'))
functions.CharLength[nchar]=LEN(REPLACE(%1$s, N' ', N'x'))
functions.CharLength[varchar]=LEN(REPLACE(%1$s, ' ', 'x'))
functions.CharLength[nvarchar]=LEN(REPLACE(%1$s, N' ', N'x'))
functions.CharLength[clob]=
functions.OctetLength[any]=DATALENGTH(%1$s)
functions.OctetLength[clob]=
functions.BitLength[any]=(DATALENGTH(%1$s) * 8)
functions.Upper[clob]=
functions.Lower[clob]=
functions.Substring[any,any]=SUBSTRING(%1$s, %2$s, LEN(%1$s))
functions.Substring[any,any,any]=SUBSTRING(%1$s, %2$s, %3$s)
#functions.Substring[clob,numeric,numeric]=
functions.Position[any,any]=CHARINDEX(%1$s, %2$s)
functions.Index[any,any]=CHARINDEX(%2$s, %1$s)
functions.Translate[any,any]=
functions.Normalize[any]=
functions.Normalize[any,any]=
functions.Normalize[any,any,any]=
functions.Random[]=
functions.Random[any]=
functions.Round[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]=
#functions.SubstringR[any,any]=CASE WHEN (%2$s) < 0 THEN (SUBSTRING( %1$s, (LEN(%1$s ) - ABS(%2$s) + 1))) ELSE (SUBSTRING(%1$s, %2$s)) END
#functions.SubstringR[any,any,any]=CASE WHEN (%2$s) < 0 THEN (SUBSTRING( %1$s, (LEN(%1$s ) - ABS(%2$s) + 1), %3$s)) ELSE (SUBSTRING(%1$s, %2$s, %3$s)) 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]=

#
# Numeric scalar functions.
#
functions.Abs[interval_day_time]=
functions.Abs[interval_year_month]=
functions.Ln[any]=LOG(%1$s)

functions.Mod[exact,exact]=((%1$s) %% (%2$s))
functions.Mod[variant,variant]=((%1$s) %% (%2$s))
functions.Mod[variant,exact]=((%1$s) %% (%2$s))
functions.Mod[exact, variant]=((%1$s) %% (%2$s))

functions.Mod[float,any]=
functions.Mod[double,any]=
functions.Mod[any,float]=
functions.Mod[any,double]=

functions.WidthBucket[any,any,any,any]=

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

#
# FDS functions.
#
functions.cast_float[any]=convert(float(53), %1$s)
functions.concat[any,any]={fn CONCAT(%1$s, %2$s)}
functions.concat[clob,clob]=

#
# Trigonometric functions.
#
## COSHYP not supported by ss.
functions.Coshyp[any]=
## SINHYP not supported by SS.
functions.Sinhyp[any]=
## TANHYP not supported by SS.
functions.Tanhyp[any]=

#
# Datetime value functions.
#
functions.CurrentDate[]=CAST(CURRENT_TIMESTAMP AS DATE)
functions.CurrentTime[]=
functions.CurrentTimestamp[]=sysdatetimeoffset()
functions.LocalTime[]=
functions.LocalTimestamp[]=
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=

#
# 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]=DATEADD(MILLISECOND, %2$s * 1000, %1$s)
functions.AddSeconds[timestamp,numeric]=DATEADD(MILLISECOND, %2$s * 1000, %1$s)
functions.AddSeconds[time_with_time_zone,numeric]=
functions.AddSeconds[timestamp_with_time_zone,numeric]=
functions.AddSeconds[interval_day_time,numeric]=
functions.AddMinutes[time,numeric]=DATEADD(MINUTE, %2$s, %1$s)
functions.AddMinutes[timestamp,numeric]=DATEADD(MINUTE, %2$s, %1$s)
functions.AddMinutes[time_with_time_zone,numeric]=
functions.AddMinutes[timestamp_with_time_zone,numeric]=
functions.AddMinutes[interval_day_time,numeric]=
functions.AddHours[time,numeric]=DATEADD(HOUR, %2$s, %1$s)
functions.AddHours[timestamp,numeric]=DATEADD(HOUR, %2$s, %1$s)
functions.AddHours[time_with_time_zone,numeric]=
functions.AddHours[timestamp_with_time_zone,numeric]=
functions.AddHours[interval_day_time,numeric]=
functions.AddDays[any,any]=DATEADD(DAY, %2$s, %1$s)
functions.AddDays[time_with_time_zone,numeric]=
functions.AddDays[timestamp_with_time_zone,numeric]=
functions.AddWeeks[any,any]=DATEADD(WEEK, %2$s, %1$s)
functions.AddWeeks[time_with_time_zone,numeric]=
functions.AddWeeks[timestamp_with_time_zone,numeric]=
functions.AddMonths[any,any]=DATEADD(MONTH, %2$s, %1$s)
functions.AddMonths[time_with_time_zone,numeric]=
functions.AddMonths[timestamp_with_time_zone,numeric]=
functions.AddQuarters[any,any]=DATEADD(QUARTER, %2$s, %1$s)
functions.AddQuarters[time_with_time_zone,numeric]=
functions.AddQuarters[timestamp_with_time_zone,numeric]=
functions.AddYears[any,any]=DATEADD(YEAR, %2$s, %1$s)
functions.AddYears[time_with_time_zone,numeric]=
functions.AddYears[timestamp_with_time_zone,numeric]=
functions.FractionalSecondsBetween[any,any]=
functions.SecondsBetween[any,any]=DATEDIFF(SECOND, %2$s, %1$s)
functions.MinutesBetween[any,any]=DATEDIFF(MINUTE, %2$s, %1$s)
functions.HoursBetween[any,any]=DATEDIFF(HOUR, %2$s, %1$s)
functions.DaysBetween[any,any]=DATEDIFF(DAY, %2$s, %1$s)
functions.WeeksBetween[any,any]=DATEDIFF(WEEK, %2$s, %1$s)
functions.MonthsBetween[any,any]=
functions.QuartersBetween[any,any]=DATEDIFF(QUARTER, %2$s, %1$s)
functions.YearsBetween[any,any]=
functions.Age[any]=
functions.DayOfWeek[any,any]=(((DATEPART(WEEKDAY, %1$s) + @@DATEFIRST - 1 - 1) %% 7 + 1 - %2$s + 7) %% 7 + 1)
functions.DayOfYear[any]=DATEPART(DAYOFYEAR, %1$s)
functions.DaysToEndOfMonth[any]=DATEDIFF(DAY, %1$s, DATEADD (DAY, -1, DATEADD(MONTH, 1, DATEADD(DAY, 1 - DATEPART(DAY, %1$s), %1$s))))
functions.FirstOfMonth[any]=DATEADD(DAY, -DAY(%1$s) + 1, %1$s)
functions.LastOfMonth[any]=DATEADD(DAY, -1, DATEADD(MONTH, 1, DATEADD(DAY, -DAY(%1$s) + 1, %1$s)))
functions.MakeTimestamp[any,any,any]=CONVERT(DATETIME, CONVERT(VARCHAR(8), ((%1$s) * 10000) + ((%2$s) * 100) + %3$s))
functions.WeekOfYear[any]=DATEPART(isowk, %1$s)
functions.YMDIntBetween[any,any]=

#
# Mappings used for transformation purposes only.
#




functions.size[text]=datalength(%1$s)

#
# Literals.
#
literals.binary=false
literals.boolean=false
literals.time_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 format specifications.
#
literals.format.date=CONVERT(DATE, '%1$04d-%2$02d-%3$02d')
literals.format.date.procedure={d '%1$04d-%2$02d-%3$02d'}
literals.format.time=CONVERT(TIME, {t '%1$02d:%2$02d:%3$02d%4$.4s'})
literals.format.time.procedure={t '%1$02d:%2$02d:%3$02d%4$.4s'}
literals.format.time_with_time_zone={t '%1$02d:%2$02d:%3$02d%4$.4s%7$c%5$02d:%6$02d'}
literals.format.timestamp=CONVERT(DATETIME2, '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.4s')
literals.format.timestamp_with_time_zone=CONVERT(DATETIMEOFFSET, '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.10s%10$c%8$02d:%9$02d')

#
# Literal Exceptions.
#
# In MS SQL Server datetime value is rendered to accuracy of 1/300 seconds
# and value are rounded to increment of .000, .003 or .007 seconds as shown below:
# 1999-12-31 23:59:59.999 is rounded to 2000-01-01 00:00:00.000
# 1999-12-31 23:59:59.998 is rounded to 1999-12-31 23:59:59.997
# 1999-12-31 23:59:59.997 is rounded to 1999-12-31 23:59:59.997
# 1999-12-31 23:59:59.996 is rounded to 1999-12-31 23:59:59.997
# 1999-12-31 23:59:59.995 is rounded to 1999-12-31 23:59:59.997
# 1999-12-31 23:59:59.994 is rounded to 1999-12-31 23:59:59.993
# 1999-12-31 23:59:59.993 is rounded to 1999-12-31 23:59:59.993
# 1999-12-31 23:59:59.992 is rounded to 1999-12-31 23:59:59.993
# 1999-12-31 23:59:59.991 is rounded to 1999-12-31 23:59:59.990
# 1999-12-31 23:59:59.990 is rounded to 1999-12-31 23:59:59.990
# The value of End_Time_Literal must be of the form
# "HH:MM:SS.FFFFFFFFF".
literals.exception.End_Time_Literal=23:59:59.998000000

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

#
# Collation sequence query
# collation.sequence.sql=<sql_statement> The query can return only a single result
#
collation.sequence.sql=SELECT CAST( ServerProperty('collation') AS VARCHAR(100)), 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
database.charset.sql=select CAST(COLLATIONPROPERTY(CAST(DATABASEPROPERTYEX(db_name(), 'Collation') as VARCHAR(100)), 'CodePage') as varchar(100))

#
# Collation sequence mappings
# collation.sequence.mapping.<sql_result>=<collation_name>,<collation_weight>
#
# NOTE: These mappings are case sensitive
#
collation.sequence.mapping.SQL_Latin1_General_CP1_CI_AI=MsSqlLatin1GeneralCp1,PRIMARY
collation.sequence.mapping.SQL_Latin1_General_CP1_CI_AS=MsSqlLatin1GeneralCp1,SECONDARY
collation.sequence.mapping.SQL_Latin1_General_CP1_CS_AS=MsSqlLatin1GeneralCp1,TERTIARY

#
# 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.datetimeoffset=timestamp with time zone

# 
# If the unsupported type returns value information in a non-standard way 
# then a way to pull apart the non standard string and a mapping to put it 
# back together. 
# datasource.type.<ccl type name>.separator=Regex for splitting the string 
# datasource.type.<ccl type name>.mapping=String formatter for putting the pieces back together 
# 
#datasource.type.timestamp_with_time_zone.separator=[ ]|[:]|[\.] 
#datasource.type.timestamp_with_time_zone.mapping=%1$s %2$s:%3$s:%4$s.%5$s%6$s:%7$s