# 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.
#
product.name=

#
# Delimiters.
#

#
# Various limits.
#
limits.maxLengthInClause=1000
limits.castClobToVarcharMaxSize=4000
limits.maxDecimalPrecision=38

#
# General settings.
#

#
# 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=BERNOULLI
sampling.rowsample=NTH

#
# Various features.
#
supports.integerDivision=false
supports.blobsInGroupBy=false
supports.blobsInOrderBy=false

supports.derivedColumnLists=false
supports.emptyStringIsNull=true
supports.concatNullIsNull=false
supports.stitchJoins=false
supports.nestedWithClause=false
supports.recursiveWithClause=false
supports.booleanExpressionsInSelectList=false
supports.nonStandardDatetimeComparison=true
supports.callProcedureInDerivedTable=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.
#

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

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


#
# Clauses.
#
clauses.Top=FETCH FIRST %1$s ROWS ONLY
clauses.At=
clauses.Window=
clauses.WithRecursive=
clauses.TableSampleBeforeAlias=true
clauses.TableSampleSystem=SAMPLE BLOCK (%1$s)@2[ SEED (%2$s)]
clauses.TableSampleBernoulli=SAMPLE (%1$s)@2[ SEED (%2$s)]
clauses.ForSystemTimeAsOf=
clauses.ForSystemTimeFrom=
clauses.ForSystemTimeBetween=

#
# Joins.
#

#
# Set operators.
#
operators.set.Except=%1$s MINUS %2$s
operators.set.Except.all=
operators.set.Intersect.all=

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

#
# Arithmetic operators.
#
operators.arithmetic.Concat[any,any]=%1$s || %2$s
operators.arithmetic.Subtract[any,datetime]=
operators.arithmetic.Subtract[variant,timestamp]=%1$s - %2$s
operators.arithmetic.Add[interval_day_time,timestamp_with_time_zone]=
operators.arithmetic.Add[interval_year_month,timestamp_with_time_zone]=
operators.arithmetic.Add[timestamp_with_time_zone,interval_day_time]=
operators.arithmetic.Add[timestamp_with_time_zone,interval_year_month]=

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

predicates.Similar=
predicates.Similar.escape=
predicates.LikeRegex=REGEXP_LIKE(%1$s, %2$s)
predicates.LikeRegex.flag=REGEXP_LIKE(%1$s, %2$s, %3$s)
predicates.Like.CaseSensitive.sql=SELECT CASE WHEN 'w' LIKE '%W%' THEN 'false' ELSE 'true' END C1 FROM ( SELECT COUNT(*) r_count FROM V$NLS_PARAMETERS) T1

#
# 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(TO_CHAR(%1$s,'YYYY-MM-DD') AS %2$s)
expressions.Cast[date,nchar]=CAST(TO_CHAR(%1$s,'YYYY-MM-DD') AS %2$s)
expressions.Cast[date,varchar]=CAST(TO_CHAR(%1$s,'YYYY-MM-DD') AS VARCHAR2(%3$d))
expressions.Cast[date,nvarchar]=CAST(TO_CHAR(%1$s,'YYYY-MM-DD') AS NVARCHAR2(%3$d))


expressions.Cast[time,text]=
expressions.Cast[time,timestamp]=
expressions.Cast[time,timestamp_with_time_zone]=

expressions.Cast[null,date]=
expressions.Cast[any,date]=TRUNC(cast(%1$s as DATE))
expressions.Cast[variant,date]=TRUNC(cast(%1$s as DATE))
expressions.Cast[timestamp,nvarchar]=CAST(TO_CHAR(cast(%1$s as TIMESTAMP(9)),'YYYY-MM-DD HH24:MI:SS.FF9') AS NVARCHAR2(%3$d))
expressions.Cast[timestamp,text]=CAST(TO_CHAR(cast(%1$s as TIMESTAMP(9)),'YYYY-MM-DD HH24:MI:SS.FF9') AS %2$s)
expressions.Cast[timestamp_with_time_zone,char]=CAST(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF9TZH:TZM') AS %2$s)
expressions.Cast[timestamp_with_time_zone,nchar]=CAST(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF9TZH:TZM') AS %2$s)
expressions.Cast[timestamp_with_time_zone,varchar]=CAST(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF9TZH:TZM') AS VARCHAR2(%3$d))
expressions.Cast[timestamp_with_time_zone,nvarchar]=CAST(TO_CHAR(%1$s,'YYYY-MM-DD HH24:MI:SS.FF9TZH:TZM') AS NVARCHAR2(%3$d))

# these casts are disabled because they sometimes fail and cause the connection to drop.
expressions.Cast[interval_day_to_second,char]=
expressions.Cast[interval_day_to_second,nchar]=
expressions.Cast[interval_day_to_second,varchar]=
expressions.Cast[interval_day_to_second,nvarchar]=
expressions.Cast[interval_year_to_month,char]=
expressions.Cast[interval_year_to_month,nchar]=
expressions.Cast[interval_year_to_month,varchar]=
expressions.Cast[interval_year_to_month,nvarchar]=

expressions.Cast[numeric,varchar]=CAST(TO_CHAR(%1$s,'TM9','NLS_NUMERIC_CHARACTERS = ''.,'' ')  AS VARCHAR2(%3$d))
expressions.Cast[numeric,nvarchar]=CAST(TO_CHAR(%1$s,'TM9','NLS_NUMERIC_CHARACTERS = ''.,'' ')  AS NVARCHAR2(%3$d))
expressions.Cast[numeric,date]=CASE %1$s WHEN 0 THEN TO_DATE('00010101','YYYYMMDD') ELSE TO_DATE(TO_CHAR(%1$s),'YYYYMMDD') END 
expressions.Cast[numeric,text]=CAST(TO_CHAR(%1$s,'TM9','NLS_NUMERIC_CHARACTERS = ''.,'' ') AS %2$s)
expressions.Cast[text,numeric]=CAST(REPLACE(%1$s,'.',SUBSTR(CAST(1.2 AS CHAR(3)),2,1)) AS %2$s)
#cast(avarchar(x) as nvarchar2(y)) fail with Error: ORA-01401: inserted value too large for column if x > y
expressions.Cast[char,nvarchar]=CAST(TO_NCHAR(%1$d) AS NVARCHAR2(%3$d))
expressions.Cast[varchar,nvarchar]=CAST(TO_NCHAR(%1$d) AS NVARCHAR2(%3$d))
expressions.Cast[any,varchar]=CAST(%1$s AS VARCHAR2(%3$d))
expressions.Cast[any,nvarchar]=CAST(%1$s AS NVARCHAR2(%3$d))
expressions.Cast[clob,char]=CAST(TO_CHAR(%1$s) AS %2$s)
expressions.Cast[clob,nchar]=CAST(TO_CHAR(%1$s) AS %2$s)
expressions.Cast[clob,varchar]=CAST(%1$s AS VARCHAR2(%3$d))
expressions.Cast[clob,nvarchar]=CAST(%1$s AS NVARCHAR2(%3$d))
expressions.Cast[clob,any]=

expressions.Cast[numeric,integer]=CAST(TRUNC(%1$s) AS INTEGER)
expressions.Cast[any,integer]=

expressions.Cast[char,date]=CAST(TO_DATE(%1$s,'YYYY-MM-DD') AS %2$s)
expressions.Cast[char,timestamp]=TO_TIMESTAMP(%1$s,'YYYY-MM-DD HH24:MI:SS.FF')
expressions.Cast[char,timestamp_with_time_zone]=TO_TIMESTAMP_TZ(%1$s,'YYYY-MM-DD HH24:MI:SS.FFTZH:TZM')
expressions.Cast[nchar,date]=CAST(TO_DATE(%1$s,'YYYY-MM-DD') AS %2$s)
expressions.Cast[nchar,timestamp]=TO_TIMESTAMP(%1$s,'YYYY-MM-DD HH24:MI:SS.FF')
expressions.Cast[nchar,timestamp_with_time_zone]=TO_TIMESTAMP_TZ(%1$s,'YYYY-MM-DD HH24:MI:SS.FFTZH:TZM')
expressions.Cast[nvarchar,date]=CAST(TO_DATE(%1$s,'YYYY-MM-DD') AS %2$s)
expressions.Cast[nvarchar,timestamp]=TO_TIMESTAMP(%1$s,'YYYY-MM-DD HH24:MI:SS.FF')
expressions.Cast[nvarchar,timestamp_with_time_zone]=TO_TIMESTAMP_TZ(%1$s,'YYYY-MM-DD HH24:MI:SS.FFTZH:TZM')
expressions.Cast[varchar,date]=CAST(TO_DATE(%1$s,'YYYY-MM-DD') AS %2$s)
expressions.Cast[varchar,timestamp]=TO_TIMESTAMP(%1$s,'YYYY-MM-DD HH24:MI:SS.FF')
expressions.Cast[varchar,timestamp_with_time_zone]=TO_TIMESTAMP_TZ(%1$s,'YYYY-MM-DD HH24:MI:SS.FFTZH:TZM')
expressions.Cast[text,xml]=
expressions.Cast[blob,xml]=
expressions.Cast[blob,blob]=

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

#
# Extract expression.
#
expressions.Extract.HOUR[timestamp]=EXTRACT(HOUR FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.HOUR[date]=EXTRACT(HOUR FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.HOUR[time]=EXTRACT(HOUR FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.HOUR[timestamp_with_time_zone]=EXTRACT(HOUR FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.MINUTE[timestamp]=EXTRACT(MINUTE FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.MINUTE[date]=EXTRACT(MINUTE FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.MINUTE[time]=EXTRACT(MINUTE FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.MINUTE[timestamp_with_time_zone]=EXTRACT(MINUTE FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.SECOND[timestamp]=EXTRACT(SECOND FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.SECOND[date]=EXTRACT(SECOND FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.SECOND[time]=EXTRACT(SECOND FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.SECOND[timestamp_with_time_zone]=EXTRACT(SECOND FROM CAST((%1$s) AS TIMESTAMP))
expressions.Extract.EPOCH[any]=

#
# Trim expression.
#

#
# Windowed aggregates (SQL/OLAP).
#
olap.Count[blob]=COUNT(CASE WHEN %1$s IS NOT NULL THEN 1 END)
olap.Tertile[]=
olap.Difference[any]=
olap.Collect[any]=
olap.NthValue[blob,any]=
olap.NthValue[blob,any,any]=
olap.NthValue[blob,any,any,any]=
olap.NthValue[clob,any]=
olap.NthValue[clob,any,any]=
olap.NthValue[clob,any,any,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


#
# Aggregates.
#
aggregates.Count[blob]=COUNT(CASE WHEN %1$s IS NOT NULL THEN 1 END)
aggregates.Sum[interval_day_to_second]=
aggregates.Avg[interval_day_to_second]=
aggregates.Sum[interval_year_to_month]=
aggregates.Avg[interval_year_to_month]=
aggregates.ArrayAgg[any]=
aggregates.ArrayAgg[any,any]=
aggregates.Collect[any]=
aggregates.ApproxCountDistinct[blob]=
aggregates.ApproxCountDistinct[clob]=

#
# Aggregates (distinct).
#
aggregates.Sum.distinct[interval_day_to_second]=
aggregates.Avg.distinct[interval_day_to_second]=
aggregates.Sum.distinct[interval_year_to_month]=
aggregates.Avg.distinct[interval_year_to_month]=
aggregates.Count.distinct[blob]=

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

#
# Linear regression aggregates.
#

#
# Character scalar functions.
#
functions.CharLength[any]=LENGTH(%1$s)
functions.OctetLength[any]=LENGTHB(%1$s)
functions.BitLength[any]=(LENGTHB(%1$s) * 8)
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]=INSTR(%2$s, %1$s)
functions.Index[any,any]=INSTR(%1$s, %2$s)
functions.Translate[any,any]=
functions.Normalize[any]=
functions.Normalize[any,any]=
functions.Normalize[any,any,any]=

#
# Regular expression functions.
# Oracle uses POSIX regular expressions. Need to determine the difference between XQuery and POSIX.
#
functions.SubstringRegex[any,any,any,any,any]=
functions.OccurrencesRegex[any,any,any,any]=
functions.PositionRegex[any,any,any,any,any,any]=

#Substring function to negative START value to parse the input string from its rightmost end.
functions.SubstringR[any,any]=SUBSTR(%1$s, %2$s)
functions.SubstringR[any,any,any]=SUBSTR(%1$s, %2$s, %3$s)

#
# Numeric scalar functions.
#
functions.Abs[interval_day_time]=
functions.Abs[interval_year_month]=
functions.Ceiling[any]=CEIL(%1$s)
functions.Round[any,any,any]=
functions.Log10[any]=LOG(10,%1$s)
functions.Random[]=
functions.Random[any]=

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

#
# Trigonometric functions.
#

#
# Datetime value functions.
#
functions.CurrentTime[]=
functions.CurrentDate[]=TRUNC(CURRENT_DATE)
functions.LocalTime[]=
functions.CurrentTime[numeric]=
functions.LocalTime[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.JSONObject=
functions.JSONArray=

#
# Business date functions.
#
functions.AddFractionalSeconds[any,any]=
functions.AddSeconds[any,any]=(%1$s + (INTERVAL '1' SECOND * (%2$s)))
functions.AddMinutes[any,any]=(%1$s + (INTERVAL '1' MINUTE * Floor(%2$s)))
functions.AddHours[any,any]=(%1$s + (INTERVAL '1' HOUR * Floor(%2$s)))
functions.AddDays[any,any]=(%1$s + (INTERVAL '1' DAY * (%2$s)))
functions.AddDays[time_with_time_zone,numeric]=
functions.AddWeeks[any,any]=(%1$s + (INTERVAL '7' DAY * (%2$s)))
functions.AddWeeks[time_with_time_zone,numeric]=
functions.AddMonths[any,any]=CASE WHEN EXTRACT( DAY FROM %1$s - NUMTODSINTERVAL( EXTRACT( DAY FROM %1$s ), 'DAY' ) + INTERVAL '1' DAY + NUMTOYMINTERVAL( %2$s, 'MONTH' ) + INTERVAL '1' MONTH - INTERVAL '1' DAY ) < EXTRACT( DAY FROM %1$s ) THEN %1$s - NUMTODSINTERVAL( EXTRACT( DAY FROM %1$s ), 'DAY' ) + INTERVAL '1' DAY + NUMTOYMINTERVAL( %2$s, 'MONTH' ) + INTERVAL '1' MONTH - INTERVAL '1' DAY ELSE %1$s + NUMTOYMINTERVAL( %2$s, 'MONTH' ) END
functions.AddMonths[time_with_time_zone,numeric]=
functions.AddMonths[interval_year_to_month,numeric]=
functions.AddQuarters[any,any]=
functions.AddYears[any,any]=CASE WHEN TO_CHAR(%1$s,'MMDD') = '0229' AND MOD(%2$s,4) <> 0 THEN (%1$s + INTERVAL '1' DAY) + NUMTOYMINTERVAL(%2$s,'YEAR') - INTERVAL '1' DAY ELSE %1$s + NUMTOYMINTERVAL(%2$s,'YEAR') END
functions.AddYears[time_with_time_zone,numeric]=
functions.AddYears[interval_year_to_month,numeric]=
functions.FractionalSecondsBetween[any,any]=
functions.SecondsBetween[any,any]=
functions.MinutesBetween[any,any]=
functions.HoursBetween[any,any]=
functions.DaysBetween[any,any]=(TRUNC( CAST( %1$s AS TIMESTAMP ) ) - TRUNC( CAST( %2$s AS TIMESTAMP ) ))
functions.WeeksBetween[any,any]=
functions.MonthsBetween[any,any]=TRUNC( MONTHS_BETWEEN( %1$s, %2$s ), 0 )
functions.QuartersBetween[any,any]=
functions.YearsBetween[any,any]=TRUNC( ( MONTHS_BETWEEN( %1$s, %2$s) / 12 ), 0 )
functions.Age[any]=
functions.DayOfWeek[any,any]=(MOD( MOD( TO_NUMBER( TO_CHAR( %1$s, 'D' ) ) - TO_NUMBER( TO_CHAR( TO_DATE( '2003-01-06', 'YYYY-MM-DD' ), 'D' ) ) + 7, 7 ) + 1 - %2$s + 7, 7 ) + 1)
functions.DayOfYear[any]=TO_NUMBER( TO_CHAR( %1$s, 'DDD' ) )
functions.DaysToEndOfMonth[any]=(EXTRACT( DAY FROM LAST_DAY(%1$s) ) - EXTRACT( DAY FROM %1$s ))
functions.FirstOfMonth[any]=(%1$s - NUMTODSINTERVAL(EXTRACT(DAY FROM %1$s)-1, 'DAY'))
functions.LastOfMonth[any]=(%1$s + NUMTODSINTERVAL(EXTRACT(DAY FROM LAST_DAY(%1$s)) - EXTRACT(DAY FROM %1$s), 'DAY'))
functions.MakeTimestamp[any,any,any]=TO_TIMESTAMP( ( LPAD( %1$d, 4, '0' ) || '-' || LPAD( %2$d, 2, '0' ) || '-' || LPAD( %3$d, 2, '0' ) ), 'YYYY-MM-DD' )
functions.WeekOfYear[any]=TO_NUMBER( TO_CHAR( %1$s, 'IW' ) )
functions.YMDIntBetween[any,any]=

#
# Literals.
#
literals.time=false
literals.time_with_time_zone=false
literals.timetamp_with_time_zone=true
literals.interval_day=false
literals.interval_day_to_hour=false
literals.interval_day_to_minute=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_month=false

#
# Literal format specifications.
#
literals.format.binary=0x%s
literals.format.date={d '%1$04d-%2$02d-%3$02d'}
literals.format.time={t '%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={ts '%1$04d-%2$02d-%3$02d %4$02d:%5$02d:%6$02d%7$.10s'}
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_year_to_month=INTERVAL '%4$s%1$d-%2$02d' YEAR(9) TO MONTH
literals.format.interval_day_to_second=INTERVAL '%8$s%1$d %2$02d:%3$02d:%4$02d%5$.10s' DAY(9) TO SECOND(9)
#
# Data types.
#
dataType.long=false
dataType.time=false
dataType.clob=false
dataType.time_with_time_zone=false
dataType.interval_day=false
dataType.interval_day_to_hour=false
dataType.interval_day_to_minute=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_month=false
dataType.period=false
dataType.datalink=false
#dataType.nvarchar=false

dataType.comparable[char,nchar]=false
dataType.comparable[char,nvarchar]=false
dataType.comparable[varchar,nvarchar]=false
dataType.comparable[varchar,nchar]=false
dataType.comparable[nchar,char]=false
dataType.comparable[nchar,varchar]=false
dataType.comparable[nvarchar,varchar]=false
dataType.comparable[nvarchar,char]=false

dataType.promotion[char,nchar]=true
dataType.promotion[varchar,nchar]=true
dataType.promotion[char,nvarchar]=true
dataType.promotion[varchar,nvarchar]=true

#
# Collation sequence query
# collation.sequence.sql=<sql_statement> The query can return only a single result
#
collation.sequence.sql=SELECT sort_tbl.sort_val || '.' || charset_tbl.charset_val, 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 AS sort_val FROM V$NLS_PARAMETERS WHERE PARAMETER IN ( 'NLS_SORT')) sort_tbl, (SELECT VALUE AS charset_val FROM V$NLS_PARAMETERS WHERE PARAMETER IN ( 'NLS_CHARACTERSET')) charset_tbl

#
# Collation sequence mappings
# collation.sequence.mapping.<sql_result>=<collation_name>,<collation_weight>
#
# NOTE: These mappings are case sensitive
#
collation.sequence.mapping.BINARY.WE8MSWIN1252=OrWe8mswin1252,TERTIARY
collation.sequence.mapping.BINARY.WE8ISO8859P1=OrWe8iso8859p1,TERTIARY
collation.sequence.mapping.BINARY.US7ASCII=OrWe8iso8859p1,TERTIARY
collation.sequence.mapping.BINARY.AL32UTF8=UnicodeCodepoint,IDENTICAL