analytics/configuration/xqe/sap_iq.properties

#IBM Confidential
# 
#OCO Source Materials
# 
#BI and PM: rdbmscert
# 
#(C) Copyright IBM Corp. 2009,2020
# 
#The source code for this program is not published or otherwise divested of its trade secrets,
#irrespective of what has been deposited with the U.S. Copyright Office
# 

# 
# Delimiters
# 
# While a vendor may parse a statement with comments it may strip them out and the server not see them
delimiters.commentBegin=/*
delimiters.commentEnd=*/
# delimiters.catalogDelimiter=
# delimiters.schemaDelimiter=
# delimiters.tableDelimiter=
# delimiters.columnDelimiter=
# delimiters.identifierQuoteString=
# delimiters.searchStringEscape=
# delimiters.catalogSeparator=

# 
# Keywords
# 
keywords.columnAlias=AS

# 
# Limits
# 
# Normally these values would be derived from the JDBC driver DatabaseMetadata
# limits.maxBinaryLiteralLength=
# limits.maxCharLiteralLength=
# limits.maxColumnNameLength=
# limits.maxColumnsInGroupby=
# limits.maxColumnsInIndex=
# limits.maxColumnsInOrderBy=
# limits.maxColumnsInSelect=
# limits.maxColumnsInTable=
# limits.maxConnections=
# limits.maxCursorNameLength=
# limits.maxIndexLength=
# limits.maxSchemaNameLength=
# limits.maxProcedureNameLength=
# limits.maxCatalogNameLength=
# limits.maxRowSize=
# limits.maxStatementLength=
# limits.maxStatements=
# limits.maxTableNameLength=
# limits.maxTablesInSelect=
# limits.maxUserNameLength=
# limits.defaultTransactionIsolation=
# limits.maxLengthInClause

# 
# General
# 
# 
# Null ordering
# 
# No support is provided for vendors who change how nulls sort based on data type.
general.nullsAreSortedAtEnd=false
general.nullsAreSortedAtStart=false
general.nullsAreSortedHigh=false
general.nullsAreSortedLow=true
# Unable to specificy how nulls order on a cursor.
general.nullsOrdering=false


# 
# Various
# 
supports.columnAliasing=true
supports.tableCorrelationNames=true
supports.expressionsInOrderBy=true
supports.orderByAlias=true
supports.orderByName=true
supports.orderByOrdinal=true
supports.expressionsInINPredicate=true
supports.likeEscapeClause=true
supports.fullOuterJoins=true
supports.outerJoins=true
supports.stitchJoins=false
# Subqueries not supported in Group-by
# Subquery column alias not supported
supports.subqueriesInComparisons=true
supports.subqueriesInExists=true
supports.subqueriesInIns=true
supports.subqueriesInQuantifieds=true
supports.subqueriesInCase=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
# Does not allow grouping on non project column
supports.blobsInGroupBy=false
supports.blobsInOrderBy=false
supports.emptyStringIsNull=false
supports.concatNullIsNull=false
supports.expressionsInGroupBy=false
supports.parameterMarkers=false
supports.constantsInWindows=false
supports.callProcedureInDerivedTable=false
supports.join.subqueriesInOnClause=false
supports.top.0=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
# 
# 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
# Does not enforce ISO SQL lateral join exceptions
tables.lateral.derived=false

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

# 
# Clauses
# 
clauses.From=FROM
clauses.Where=WHERE
clauses.GroupBy=GROUP BY
clauses.Having=HAVING
# Recursive form of common table expression not supported
# Common table expression cannot be used within a derived table
clauses.With=WITH
clauses.OrderBy=ORDER BY
clauses.Distinct=DISTINCT
clauses.Top=TOP %1$s
clauses.Top.Position=distinct.top
clauses.TableSampleSystem=
clauses.TableSampleBernoulli=


# 
# Joins
# 
# Does not allow on condition to use set functions
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
joins.RightNested=(%1$s)

# 
# Set Operators
# 
# One or more set operations does not follow ISO data type combination rules. Can effect set operations, CASE, COALESCE...
operators.set.Union=
operators.set.Union.all=
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=

# 
# Arithmetic and Character operators
# 
operators.arithmetic.Add[any,any]=%1$s + %2$s
operators.arithmetic.Subtract[any,any]=%1$s - %2$s
operators.arithmetic.Subtract[datetime,any]=
operators.arithmetic.Subtract[any,datetime]=
operators.arithmetic.Multiply[any,any]=%1$s * %2$s
operators.arithmetic.Divide[any,any]=%1$s / %2$s
operators.arithmetic.Divide[any,integer]=%1$s / cast(%2$s as DOUBLE)
operators.arithmetic.Divide[integer, any]= cast(%1$s as DOUBLE) / %2$s
operators.arithmetic.UnaryPlus[any]=+%1$s
operators.arithmetic.Negate[any]=-%1$s
operators.arithmetic.Concat[any,any]=%1$s || %2$s
operators.arithmetic.Mod[any,float]=
operators.arithmetic.Mod[any,double]=
operators.arithmetic.Mod[any,any]=MOD(%1$2, %2$s)


# 
# Grouping Operators
# 
operators.groupBy.Rollup=ROLLUP
operators.groupBy.Cube=CUBE
operators.groupBy.GroupingSets= 

# 
# Comparison Predicates
# 

#
# Comparisons involving floats and doubles can be inaccurate due how they are represented
# on the server
#

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[decimal,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

# 
# Predicates
# 
predicates.In[any,any]=%1$s IN ( %2$s )
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.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.LikeRegex=
predicates.Overlaps[any,any,any,any]=
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]=

# 
# Conditional expressions
# 
# One or more case operations does not follow ISO type rules.
expressions.SimpleCase=CASE
expressions.SearchedCase=CASE
#expressions.Coalesce[timestamp,any]= 
expressions.Coalesce=COALESCE(%1$s)
#expressions.Coalesce[numeric,timestamp]= 
#expressions.Coalesce[date,timestamp]= 
expressions.NullIf=NULLIF(%1$s, %2$s)
#expressions.NullIf[timestamp,any]= 
#expressions.NullIf[date,timestamp]= 
# NULLIF(%1$s, %2$s) is equivalent to CASE WHEN %1$s = %2$s THEN NULL ELSE %1$s END

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

# 
# Cast
# 
expressions.Cast[any,any]=CAST(%1$s AS %2$s)
expressions.Cast[time,timestamp]=
# Precision is lost, fractional seconds are not rendered
expressions.Cast[time,text]=
expressions.Cast[timestamp,text]=

# 
# Extract
# 
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[timestamp]=(DATEPART(SECOND, %1$s) + (DATEPART(MILLISECOND, %1$s ) / 1000.0))
expressions.Extract.SECOND[time]=DATEPART(SECOND, %1$s)

# 
# Trim
# Only supports trimming of spaces
expressions.Trim.BOTH[any]=TRIM(%1$s)
expressions.Trim.LEADING[any]=LTRIM(%1$s)
expressions.Trim.TRAILING[any]=RTRIM(%1$s)
expressions.Trim.BOTH[any,any]=
expressions.Trim.LEADING[any,any]=
expressions.Trim.TRAILING[any,any]=


# 
# Window clause
# 
clauses.Window= 
olap.PartitionBy=PARTITION BY %1$s
# Lack of window ordering impacts many aggregates being pushed
# Unable to specify a literal in window ordering
# Unable to specify ordering in a window
general.nullsOrderingInWindowSpecification=false
olap.OrderBy= ORDER BY %1$s

# 
# Window specification. 
# Sybase IQ interprets missing frame specification with order by as a "RANGE".
# 
olap.Window.Specification[POF]=true
olap.Window.Specification[PF]=true
olap.Window.Specification[OF]=true
olap.Window.Specification[PO]=false
olap.Window.Specification[P]=true
olap.Window.Specification[O]=false
olap.Window.Specification[F]=true
olap.Window.Specification[]=true

# 
# Olap Distinct
# 
olap.Min.distinct[any]= 
olap.Max.distinct[any]= 
olap.Sum.distinct[any]= 
olap.Avg.distinct[any]= 
olap.Count.distinct[any]= 

# 
# Aggregates
# 
aggregates.Max[timestamp]= 
aggregates.Max[time]=MAX(%1$s)
aggregates.Max[text]=MAX(%1$s)
aggregates.Max[numeric]=MAX(%1$s)
aggregates.Max[date]=MAX(%1$s)
aggregates.Min[timestamp]= 
aggregates.Min[time]=MIN(%1$s)
aggregates.Min[text]=MIN(%1$s)
aggregates.Min[numeric]=MIN(%1$s)
aggregates.Min[date]=MIN(%1$s)
aggregates.Count[any]=COUNT(%1$s)
aggregates.CountStar[]=COUNT(*)
aggregates.Sum[any]=SUM(%1$s)
aggregates.Avg[any]=AVG(%1$s)
aggregates.StdDevPop[any]=STDDEV_POP(%1$s)
aggregates.StdDevSamp[any]=STDDEV_SAMP(%1$s)
aggregates.VarPop[any]=VAR_POP(%1$s)
aggregates.VarSamp[any]=VAR_SAMP(%1$s)
aggregates.Grouping[any]=
# Disabled due to XMLELEMENT being returned as long varchar and not SQLXML
aggregates.XMLAgg=
aggregates.CumeDistH[any,any]=
aggregates.PercentileCont[any,any]=PERCENTILE_CONT(%1$s) WITHIN GROUP (ORDER BY %2$s)
aggregates.PercentileDisc[any,any]=PERCENTILE_DISC(%1$s) WITHIN GROUP (ORDER BY %2$s)
aggregates.Median[any]=MEDIAN(%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]=CORR(%1$s, %2$s)
aggregates.CovarPop[any,any]=COVAR_POP(%1$s, %2$s)
aggregates.CovarSamp[any,any]=COVAR_SAMP(%1$s, %2$s)
aggregates.RegrAvgX[any,any]=REGR_AVGX(%1$s, %2$s)
aggregates.RegrAvgY[any,any]=REGR_AVGY(%1$s, %2$s)
aggregates.RegrCount[any,any]=REGR_COUNT(%1$s, %2$s)
aggregates.RegrIntercept[any,any]=REGR_INTERCEPT(%1$s, %2$s)
aggregates.RegrR2[any,any]=REGR_R2(%1$s, %2$s)
aggregates.RegrSlope[any,any]=REGR_SLOPE(%1$s, %2$s)
aggregates.RegrSXX[any,any]=REGR_SXX(%1$s, %2$s)
aggregates.RegrSXY[any,any]=REGR_SXY(%1$s, %2$s)
aggregates.RegrSYY[any,any]=REGR_SYY(%1$s, %2$s)

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

# 
# Character scalar functions
# 
functions.Upper[any]=UPPER(%1$s)
functions.Lower[any]=LOWER(%1$s)
functions.Upper[blob]=
functions.Lower[blob]=
# Some position cases did not pass and should be reviewed.
functions.Position[any,any]=
functions.Substring[any,any]=SUBSTR(%1$s, %2$s)
functions.Substring[any,any,any]=SUBSTR(%1$s, %2$s, %3$s)
functions.Ascii[any]=
functions.CharLength[any]=CHAR_LENGTH(%1$s)
functions.OctetLength[any]=OCTET_LENGTH(%1$s)
functions.BitLength[any]=BIT_LENGTH(%1$s)
functions.Position[any,any]=
functions.Index[any,any]=
functions.Translate[any,any]=
functions.Normalize[any]=
functions.Normalize[any,any]=
functions.Normalize[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 (SUBSTR( %1$s, (CHAR_LENGTH(%1$s ) - ABS(%2$s) + 1))) ELSE (SUBSTR(%1$s, %2$s)) END
functions.SubstringR[any,any,any]=CASE WHEN (%2$s) < 0 THEN (SUBSTR( %1$s, (CHAR_LENGTH(%1$s ) - ABS(%2$s) + 1), %3$s)) ELSE (SUBSTR(%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[any]=ABS(%1$s)
functions.Abs[interval_day_time]=
functions.Abs[interval_year_month]=
functions.Ceiling[any]=CEIL(%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)
fumctions.Power[any,any]=POWER(%1$s, %2$s)
functions.Random[]=
functions.Random[any]=
functions.Round[any,any]=ROUND(%1$s, %2$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]= 
functions.Sin[any]=SIN(%1$s)
functions.Sinhyp[any]= 
functions.Tan[any]=TAN(%1$s)
functions.Tanhyp[any]= 

# 
# 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(*)
# Sybase IQ does support cume_dist but it does not support null ordering
# in a window specification. Another restriction is the cume_dist can only have one
# key in the 'order by' clause. This causes an issue with the transformation ConvertNullOrderingInSort,
# which gets around the null ordering issue by adding a second sort key to sort nulls properly. 
# All that to say, we need to process this function locally.
# Olap lag did not throw expected exceptions
olap.Lag[any]=LAG(%1$s)
olap.Lag[any,any]=LAG(%1$s, %2$s)
olap.Lag[any,double]=
olap.Lag[any,float]=
olap.Lag[any,any,any]=LAG(%1$s, %2$s, %3$s)
olap.Lag[any,double,any]=
olap.Lag[any,float,any]=
olap.Lag[any,any,any,any]=
# Olap lead did not throw expected exceptions
olap.Lead[any]=LEAD(%1$s)
olap.Lead[any,any]=LEAD(%1$s, %2$s)
olap.Lead[any,double]=
olap.Lead[any,float]=
olap.Lead[any,any,any]=LEAD(%1$s, %2$s, %3$s)
olap.Lead[any,double,any]=
olap.Lead[any,float,any]=
olap.Lead[any,any,any,any]=
olap.NthValue[any,any]=
olap.NthValue[any,any,any]=
olap.NthValue[any,any,any,any]=
olap.NTile[any]=
olap.Tertile[]=
olap.Rank[]=RANK()
olap.DenseRank[]=DENSE_RANK()
olap.PercentRank[]=PERCENT_RANK()
olap.CumeDist[]=
olap.RatioToReport[any]=
olap.RowNumber[]=
olap.Difference[any]=
olap.FirstValue[any]=FIRST_VALUE(%1$s)
olap.LastValue[any]=LAST_VALUE(%1$s)
olap.PercentileCont[any,any]=
olap.PercentileDisc[any,any]=
olap.Median[any]=MEDIAN(%1$s)
olap.Collect[any]=

# 
# Temporal value expressions
# 
# Note: JDBC does not define fractional seconds for TIME data type.
functions.CurrentDate[]=CURRENT DATE
functions.CurrentTime[]=CURRENT TIME
functions.CurrentTimestamp[]=CURRENT TIMESTAMP
functions.CurrentTimestamp[numeric]=CURRENT TIMESTAMP 
functions.CurrentTime[numeric]=
#Ignore the numeric value as in classic stack
functions.LocalTime[]=CURRENT TIME
functions.LocalTimestamp[]=CURRENT TIMESTAMP 
functions.LocalTime[numeric]=CURRENT TIME
functions.LocalTimestamp[numeric]=CURRENT TIMESTAMP 

# 
# XML Functions
# disabled until the XML support is formalized.
# 
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 functions.
# 
functions.AddFractionalSeconds[any,any]=
functions.AddSeconds[any,any]=DATEADD( SECOND, %2$s, %1$s )
functions.AddMinutes[any,any]=DATEADD( MINUTE, %2$s, %1$s )
functions.AddHours[any,any]=DATEADD( HOUR, %2$s, %1$s )
functions.AddDays[any,any]=DATEADD( DAY, %2$s, %1$s )
functions.AddWeeks[any,any]=DATEADD( WEEK, %2$s, %1$s )
functions.AddMonths[any,any]=DATEADD( MONTH, %2$s, %1$s )
functions.AddQuarters[any,any]=DATEADD( QUARTER, %2$s, %1$s )
functions.AddYears[any,any]=DATEADD( YEAR, %2$s, %1$s )
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]=DATEDIFF( MONTH, %2$s, %1$s )
functions.QuartersBetween[any,any]=DATEDIFF( QUARTER, %2$s, %1$s )
functions.YearsBetween[any,any]=DATEDIFF( YEAR, %2$s, %1$s )
functions.Age[any]=
functions.WeekOfYear[any]=
functions.YMDIntBetween[any,any]=
functions.DayOfWeek[any,any]=(MOD(( MOD(( DATEPART( WEEKDAY, %1$s ) + 5 ), 7 ) - %2$s + 8 ), 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, -DATEPART( 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]=CAST( YMD(%1$s, %2$s, %3$s ) AS TIMESTAMP )

# 
# 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=false
literals.clob=true
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.date=true
literals.time=true
literals.time_with_time_zone=false
literals.timestamp=true
literals.timestamp_with_time_zone=false
literals.binary=true
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.clob='%s'
literals.format.date=CAST ('%1$04d-%2$02d-%3$02d' as date)
literals.format.nchar=N'%s'
literals.format.nvarchar=N'%s'
literals.format.time=cast ('%1$02d:%2$02d:%3$02d%4$.4s' as time)
literals.format.timestamp=cast('%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.7s' as timestamp)
literals.format.varchar='%s'
# 
# DataTypes
# 
dataType.smallint=true
dataType.integer=true
dataType.long=true
dataType.decimal=true
dataType.float=true
dataType.double=true
dataType.char=true
dataType.nchar=false
dataType.varchar=true
dataType.nvarchar=false
dataType.clob=false
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=false
dataType.period=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

#
# Sybase IQ is not case-sensitive for identifiers
#
supports.mixedCaseIdentifiers=false
supports.mixedCaseQuotedIdentifiers=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=SELECT default_collation, 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 SYSINFO
# 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