java.lang.Object
- org.hibernate.dialect.function.CommonFunctionFactory

```
public class CommonFunctionFactory
extends Object
```
Enumeratoes common function template definitions. Centralized for easier use from dialects.

Constructor Summary

Constructors
Constructor Description

CommonFunctionFactory(FunctionContributions functionContributions)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`adddateSubdateAddtimeSubtime()`	MySQL style
`void`	`addMonths()`
`void`	`addYearsMonthsDaysHoursMinutesSeconds()`
`void`	`aggregates(Dialect dialect, SqlAstNodeRenderingMode inferenceArgumentRenderingMode)`
`void`	`array()`	H2, HSQL array() constructor function
`void`	`array_hsql()`	H2, HSQL array() constructor function
`void`	`array_oracle()`	Oracle array() constructor function
`void`	`array_postgresql()`	CockroachDB and PostgreSQL array() constructor function
`void`	`array_spanner()`	Google Spanner array() constructor function
`void`	`arrayAggregate()`	H2, HSQL, CockroachDB and PostgreSQL array_agg() function
`void`	`arrayAggregate_jsonArrayagg()`	Oracle array_agg() function
`void`	`arrayAppend_operator()`	H2 and HSQLDB array_append() function
`void`	`arrayAppend_oracle()`	Oracle array_append() function
`void`	`arrayAppend_postgresql()`	CockroachDB and PostgreSQL array_append() function
`void`	`arrayConcat_operator()`	H2 and HSQLDB array_concat() function
`void`	`arrayConcat_oracle()`	Oracle array_concat() function
`void`	`arrayConcat_postgresql()`	CockroachDB and PostgreSQL array_concat() function
`void`	`arrayContains_h2(int maximumArraySize)`	H2 array_contains() function
`void`	`arrayContains_hsql()`	HSQL array_contains() function
`void`	`arrayContains_oracle()`	Oracle array_contains() function
`void`	`arrayContains_postgresql()`	CockroachDB and PostgreSQL array contains operator
`void`	`arrayFill_cockroachdb()`	Cockroach array_fill() function
`void`	`arrayFill_h2()`	H2 array_fill() function
`void`	`arrayFill_hsql()`	HSQLDB array_fill() function
`void`	`arrayFill_oracle()`	Oracle array_fill() function
`void`	`arrayFill_postgresql()`	PostgreSQL array_fill() function
`void`	`arrayGet_bracket()`	CockroachDB and PostgreSQL array_get() function via bracket syntax
`void`	`arrayGet_h2()`	H2 array_get() function via bracket syntax
`void`	`arrayGet_oracle()`	Oracle array_get() function
`void`	`arrayGet_unnest()`	HSQL array_get() function
`void`	`arrayLength_cardinality()`	H2, HSQLDB, CockroachDB and PostgreSQL array_length() function
`void`	`arrayLength_oracle()`	Oracle array_length() function
`void`	`arrayOverlaps_h2(int maximumArraySize)`	H2 array_overlaps() function
`void`	`arrayOverlaps_hsql()`	HSQL array_overlaps() function
`void`	`arrayOverlaps_oracle()`	Oracle array_overlaps() function
`void`	`arrayOverlaps_postgresql()`	CockroachDB and PostgreSQL array overlaps operator
`void`	`arrayPosition_h2(int maximumArraySize)`	H2 array_position() function
`void`	`arrayPosition_hsql()`	HSQL array_position() function
`void`	`arrayPosition_oracle()`	Oracle array_position() function
`void`	`arrayPosition_postgresql()`	CockroachDB and PostgreSQL array_position() function
`void`	`arrayPositions_h2(int maximumArraySize)`	H2 array_positions() function
`void`	`arrayPositions_hsql()`	HSQL array_positions() function
`void`	`arrayPositions_oracle()`	Oracle array_positions() function
`void`	`arrayPositions_postgresql()`	CockroachDB and PostgreSQL array_positions() function
`void`	`arrayPrepend_operator()`	H2 and HSQLDB array_prepend() function
`void`	`arrayPrepend_oracle()`	Oracle array_prepend() function
`void`	`arrayPrepend_postgresql()`	CockroachDB and PostgreSQL array_prepend() function
`void`	`arrayRemove()`	CockroachDB and PostgreSQL array_remove() function
`void`	`arrayRemove_h2(int maximumArraySize)`	H2 array_remove() function
`void`	`arrayRemove_hsql()`	HSQL array_remove() function
`void`	`arrayRemove_oracle()`	Oracle array_remove() function
`void`	`arrayRemoveIndex_h2(int maximumArraySize)`	H2 array_remove_index() function
`void`	`arrayRemoveIndex_oracle()`	Oracle array_remove_index() function
`void`	`arrayRemoveIndex_unnest(boolean castEmptyArrayLiteral)`	HSQL, CockroachDB and PostgreSQL array_remove_index() function
`void`	`arrayReplace()`	CockroachDB and PostgreSQL array_replace() function
`void`	`arrayReplace_h2(int maximumArraySize)`	H2 array_replace() function
`void`	`arrayReplace_oracle()`	Oracle array_replace() function
`void`	`arrayReplace_unnest()`	HSQL array_replace() function
`void`	`arraySet_h2(int maximumArraySize)`	H2 array_set() function
`void`	`arraySet_hsql()`	HSQL array_set() function
`void`	`arraySet_oracle()`	Oracle array_set() function
`void`	`arraySet_unnest()`	CockroachDB and PostgreSQL array_set() function
`void`	`arraySlice()`	H2 array_slice() function
`void`	`arraySlice_operator()`	CockroachDB and PostgreSQL array_slice() function
`void`	`arraySlice_oracle()`	Oracle array_slice() function
`void`	`arraySlice_unnest()`	HSQL array_slice() function
`void`	`arrayToString_h2(int maximumArraySize)`	H2 array_to_string() function
`void`	`arrayToString_hsql()`	HSQL array_to_string() function
`void`	`arrayToString_oracle()`	Oracle array_to_string() function
`void`	`arrayToString_postgresql()`	CockroachDB and PostgreSQL array_to_string() function
`void`	`arrayTrim_oracle()`	Oracle array_trim() function
`void`	`arrayTrim_trim_array()`	H2, HSQLDB, CockroachDB and PostgreSQL array_trim() function
`void`	`arrayTrim_unnest()`	PostgreSQL array_trim() emulation for versions before 14
`void`	`ascii()`	Very widely supported, but we don't treat this as a "standard" function because it's hard to emulate on any database that doesn't have it (e.g.
`void`	`atan2_atn2()`	Transact-SQL atan2 is misspelled
`void`	`avg_castingNonDoubleArguments(Dialect dialect, SqlAstNodeRenderingMode inferenceArgumentRenderingMode)`
`void`	`bitand()`
`void`	`bitAndOr()`	These are aggregate functions taking one argument!
`void`	`bitandorxornot_binAndOrXorNot()`	Bitwise operators, not aggregate functions!
`void`	`bitandorxornot_bitAndOrXorNot()`	Binary bitwise operators, not aggregate functions!
`void`	`bitandorxornot_operator()`	Binary bitwise operators, not aggregate functions!
`void`	`bitLength()`
`void`	`bitLength_pattern(String pattern)`
`void`	`bitLength_pattern(String pattern, String clobPattern)`
`void`	`bitLength_pattern(String pattern, SqlAstNodeRenderingMode renderingMode)`
`void`	`bitnot()`
`void`	`bitor()`
`void`	`bitxor()`
`void`	`cbrt()`
`void`	`ceiling_ceil()`
`void`	`char_chr()`
`void`	`characterLength_len()`	Transact SQL-style
`void`	`characterLength_length(String clobPattern)`
`void`	`characterLength_length(SqlAstNodeRenderingMode argumentRenderingMode)`	Oracle-style
`void`	`chr_char()`
`void`	`coalesce()`
`void`	`coalesce_value()`	SAP DB
`void`	`collate()`	Use the 'collate' operator which exists on at least Postgres, MySQL, Oracle, and SQL Server
`void`	`collate_quoted()`	HSQL requires quotes around certain collations
`void`	`concat()`
`void`	`concat_pipeOperator()`	Almost every database
`void`	`concat_pipeOperator(String clobPattern)`
`void`	`corr()`
`void`	`cosh()`
`void`	`cosh_exp()`
`void`	`cot()`
`void`	`covarPopSamp()`
`void`	`crc32()`
`void`	`currentUtcdatetimetimestamp()`
`void`	`date()`
`void`	`datediff()`	MySQL style, returns the number of days between two dates
`void`	`datepartDatename()`	Transact SQL-style
`void`	`dateTimeTimestamp()`
`void`	`dateTrunc()`	H2, DB2 and PostgreSQL native date_trunc() function
`void`	`dateTrunc_datetrunc()`	SQLServer native datetrunc() function
`void`	`daynameMonthname()`
`void`	`dayofweekmonthyear()`
`void`	`dayOfWeekMonthYear()`
`void`	`daysBetween()`
`void`	`degrees()`
`void`	`degrees_acos()`	For Oracle, HANA
`void`	`everyAny()`	These are aggregate functions taking one argument!
`void`	`everyAny_boolAndOr()`	These are aggregate functions taking one argument, for databases that can directly aggregate both boolean columns and predicates!
`void`	`everyAny_minMaxCase()`	These are aggregate functions taking one argument, for Oracle and Sybase.
`void`	`everyAny_minMaxIif()`	These are aggregate functions taking one argument, for SQL Server.
`void`	`everyAny_sumCase(boolean supportsPredicateAsExpression)`	These are aggregate functions taking one argument, for databases that have to emulate the boolean aggregation functions using sum() and case.
`void`	`format_dateFormat()`	MySQL-style (also Ingres)
`void`	`format_formatdatetime()`	H2-style (uses Java's SimpleDateFormat directly so no need to translate format)
`void`	`format_toChar()`	Usually Oracle-style (except for Informix which quite close to MySQL-style)
`void`	`format_toVarchar()`	HANA's name for to_char() is still Oracle-style
`void`	`hourMinuteSecond()`	Note that we include these for completeness, but since their names collide with the HQL abbreviations for extract(), they can't actually be called from HQL.
`void`	`hypotheticalOrderedSetAggregates()`
`void`	`hypotheticalOrderedSetAggregates_windowEmulation()`
`void`	`initcap()`
`void`	`insert()`
`void`	`insert_overlay()`	Postgres
`void`	`instr()`
`void`	`inverseDistributionOrderedSetAggregates()`
`void`	`inverseDistributionOrderedSetAggregates_windowEmulation()`
`void`	`lastDay()`
`void`	`lastDay_eomonth()`
`void`	`leastGreatest()`
`void`	`leastGreatest_minMax()`
`void`	`leastGreatest_minMaxValue()`
`void`	`leftRight()`
`void`	`leftRight_substr()`
`void`	`leftRight_substrLength()`	Emulate left via substr and right via substr and length.
`void`	`length_characterLength()`	ANSI SQL-style
`void`	`length_characterLength_pattern(String clobPattern)`
`void`	`listagg(String emptyWithinReplacement)`
`void`	`listagg_groupConcat()`
`void`	`listagg_list(String stringType)`
`void`	`listagg_stringAgg(String stringType)`
`void`	`listagg_stringAggWithinGroup(String stringType)`
`void`	`ln_log()`	For SQL Server and Sybase
`void`	`localtimeLocaltimestamp()`
`void`	`locate()`
`void`	`locate_charindex()`	Transact SQL-style
`void`	`locate_positionSubstring()`	locate() in terms of ANSI position() and substring()
`void`	`log()`	For databases where the first parameter is the base
`void`	`log_ln()`
`void`	`log_log()`	SQL Server defines parameters in reverse order
`void`	`log_loglog()`	For Sybase
`void`	`log10()`
`void`	`log10_log()`	For Oracle and HANA
`void`	`log2()`
`void`	`lowerUpper()`
`void`	`makedateMaketime()`	MySQL/CUBRID
`void`	`makeDateTimeTimestamp()`	Postgres
`void`	`math()`
`void`	`md5()`
`void`	`median()`
`void`	`median_percentileCont(boolean over)`
`void`	`median_percentileCont_castDouble()`	CockroachDB lacks implicit casting: https://github.com/cockroachdb/cockroach/issues/89965
`void`	`mod_operator()`
`void`	`monthsBetween()`
`void`	`moreHyperbolic()`
`void`	`nowCurdateCurtime()`
`void`	`nullif()`
`void`	`octetLength()`
`void`	`octetLength_pattern(String pattern)`
`void`	`octetLength_pattern(String pattern, String clobPattern)`
`void`	`octetLength_pattern(String pattern, SqlAstNodeRenderingMode renderingMode)`
`void`	`overlay()`	ANSI SQL form, supported by Postgres, HSQL
`void`	`overlayLength_overlay(boolean withCodeUnits)`	For DB2 which has a broken implementation of overlay()
`void`	`pad()`
`void`	`pad_fill()`	SAP DB
`void`	`pad_repeat()`
`void`	`pad_replicate()`	Transact-SQL
`void`	`pad_space()`	In MySQL the third argument is required
`void`	`pi()`
`void`	`pi_acos()`
`void`	`position()`	ANSI-style
`void`	`power_expLn()`
`void`	`radians()`
`void`	`radians_acos()`	For Oracle, HANA
`void`	`rand()`	Returns double between 0.0 and 1.0.
`void`	`regrLinearRegressionAggregates()`
`void`	`repeat()`
`void`	`repeat_replicate()`
`void`	`repeat_rpad()`
`void`	`replace()`
`void`	`replace_strReplace()`	Sybase
`void`	`reverse()`
`void`	`round()`
`void`	`round_floor()`	Derby (only works if the second arg is constant, as it almost always is)
`void`	`round_round()`	SQL Server
`void`	`round_roundFloor()`	PostgreSQL (only works if the second arg is constant, as it almost always is)
`void`	`rownum()`	H2/HSQL-style
`void`	`rownumInstOrderbyGroupbyNum()`	CUBRID
`void`	`rownumRowid()`	Oracle-style
`void`	`secondsBetween()`
`void`	`sha()`
`void`	`sha1()`
`void`	`sha2()`
`void`	`sinh()`
`void`	`sinh_exp()`
`void`	`soundex()`
`void`	`space()`
`void`	`square()`
`void`	`stddev()`	Warning: the semantics of this function are inconsistent between DBs.
`void`	`stddevPopSamp()`
`void`	`stddevPopSamp_stdevp()`	SQL Server-style
`void`	`stddevSamp_sumCount()`	DB2 before 11
`void`	`substr()`
`void`	`substring()`	Not the same as ANSI-style substring!
`void`	`substring_substr()`	Oracle, and many others
`void`	`substring_substringLen()`	Transact SQL-style (3 required args)
`void`	`substringFromFor()`	ANSI-style substring
`void`	`sysdate()`
`void`	`sysdateExplicitMicros()`	MySQL 5.7 precision defaults to seconds, but microseconds is better
`void`	`sysdateParens()`	MySQL requires the parens in sysdate()
`void`	`systimestamp()`
`void`	`tanh()`
`void`	`tanh_exp()`
`void`	`time()`
`void`	`timestamp()`
`void`	`toCharNumberDateTimestamp()`
`void`	`translate()`
`void`	`trigonometry()`
`void`	`trim1()`
`void`	`trim2()`
`void`	`trunc()`
`void`	`trunc_dateTrunc()`
`void`	`trunc_dateTrunc_trunc()`
`void`	`trunc_floor()`	Derby (only works if the second arg is constant, as it almost always is)
`void`	`trunc_round_datetrunc()`	SQL Server >= 16
`void`	`trunc_roundMode()`	SAP HANA
`void`	`trunc_truncate()`	MySQL
`void`	`utcDateTimeTimestamp()`
`void`	`variance()`	Warning: the semantics of this function are inconsistent between DBs.
`void`	`varianceSamp()`	DB2
`void`	`varPopSamp()`
`void`	`varPopSamp_varp()`	SQL Server-style
`void`	`varSamp_sumCount()`	DB2 before 11
`void`	`week_weekofyear()`
`void`	`weekQuarter()`
`void`	`windowFunctions()`
`void`	`yearMonthDay()`	Note that we include these for completeness, but since their names collide with the HQL abbreviations for extract(), they can't actually be called from HQL.
`void`	`yearsMonthsDaysHoursMinutesSecondsBetween()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - CommonFunctionFactory
```
public CommonFunctionFactory(FunctionContributions functionContributions)
```
- Method Detail
  - cot
```
public void cot()
```
  - log
```
public void log()
```
    For databases where the first parameter is the base
  - log_ln
```
public void log_ln()
```
  - log_log
```
public void log_log()
```
    SQL Server defines parameters in reverse order
  - log_loglog
```
public void log_loglog()
```
    For Sybase
  - ln_log
```
public void ln_log()
```
    For SQL Server and Sybase
  - log10
```
public void log10()
```
  - log10_log
```
public void log10_log()
```
    For Oracle and HANA
  - log2
```
public void log2()
```
  - radians
```
public void radians()
```
  - radians_acos
```
public void radians_acos()
```
    For Oracle, HANA
  - degrees
```
public void degrees()
```
  - degrees_acos
```
public void degrees_acos()
```
    For Oracle, HANA
  - sinh
```
public void sinh()
```
  - sinh_exp
```
public void sinh_exp()
```
  - cosh
```
public void cosh()
```
  - cosh_exp
```
public void cosh_exp()
```
  - tanh
```
public void tanh()
```
  - tanh_exp
```
public void tanh_exp()
```
  - moreHyperbolic
```
public void moreHyperbolic()
```
  - trunc
```
public void trunc()
```
  - trunc_dateTrunc
```
public void trunc_dateTrunc()
```
  - trunc_dateTrunc_trunc
```
public void trunc_dateTrunc_trunc()
```
  - trunc_truncate
```
public void trunc_truncate()
```
    MySQL
  - trunc_round_datetrunc
```
public void trunc_round_datetrunc()
```
    SQL Server >= 16
  - trunc_floor
```
public void trunc_floor()
```
    Derby (only works if the second arg is constant, as it almost always is)
  - trunc_roundMode
```
public void trunc_roundMode()
```
    SAP HANA
  - rand
```
public void rand()
```
    Returns double between 0.0 and 1.0. First call may specify a seed value.
  - median
```
public void median()
```
  - median_percentileCont
```
public void median_percentileCont(boolean over)
```
  - median_percentileCont_castDouble
```
public void median_percentileCont_castDouble()
```
    CockroachDB lacks implicit casting: https://github.com/cockroachdb/cockroach/issues/89965
  - stddev
```
public void stddev()
```
    Warning: the semantics of this function are inconsistent between DBs.
    
    On Postgres it means stdev_samp()
    On Oracle, DB2, MySQL it means stdev_pop()
  - variance
```
public void variance()
```
    Warning: the semantics of this function are inconsistent between DBs.
    
    On Postgres it means var_samp()
    On Oracle, DB2, MySQL it means var_pop()
  - stddevPopSamp
```
public void stddevPopSamp()
```
  - varPopSamp
```
public void varPopSamp()
```
  - covarPopSamp
```
public void covarPopSamp()
```
  - corr
```
public void corr()
```
  - regrLinearRegressionAggregates
```
public void regrLinearRegressionAggregates()
```
  - varianceSamp
```
public void varianceSamp()
```
    DB2
  - varSamp_sumCount
```
public void varSamp_sumCount()
```
    DB2 before 11
  - stddevSamp_sumCount
```
public void stddevSamp_sumCount()
```
    DB2 before 11
  - stddevPopSamp_stdevp
```
public void stddevPopSamp_stdevp()
```
    SQL Server-style
  - varPopSamp_varp
```
public void varPopSamp_varp()
```
    SQL Server-style
  - pi
```
public void pi()
```
  - pi_acos
```
public void pi_acos()
```
  - soundex
```
public void soundex()
```
  - trim2
```
public void trim2()
```
  - trim1
```
public void trim1()
```
  - pad
```
public void pad()
```
  - pad_space
```
public void pad_space()
```
    In MySQL the third argument is required
  - pad_replicate
```
public void pad_replicate()
```
    Transact-SQL
  - pad_repeat
```
public void pad_repeat()
```
  - pad_fill
```
public void pad_fill()
```
    SAP DB
  - reverse
```
public void reverse()
```
  - space
```
public void space()
```
  - repeat
```
public void repeat()
```
  - repeat_rpad
```
public void repeat_rpad()
```
  - leftRight
```
public void leftRight()
```
  - leftRight_substr
```
public void leftRight_substr()
```
  - leftRight_substrLength
```
public void leftRight_substrLength()
```
    Emulate left via substr and right via substr and length. This function is for Apache Derby and uses SqlAstNodeRenderingMode.NO_PLAIN_PARAMETER for the right function emulation, because length in Apache Derby can't handle plain parameters.
  - repeat_replicate
```
public void repeat_replicate()
```
  - md5
```
public void md5()
```
  - initcap
```
public void initcap()
```
  - instr
```
public void instr()
```
  - substr
```
public void substr()
```
  - translate
```
public void translate()
```
  - bitand
```
public void bitand()
```
  - bitor
```
public void bitor()
```
  - bitxor
```
public void bitxor()
```
  - bitnot
```
public void bitnot()
```
  - bitandorxornot_bitAndOrXorNot
```
public void bitandorxornot_bitAndOrXorNot()
```
    Binary bitwise operators, not aggregate functions!
  - bitandorxornot_binAndOrXorNot
```
public void bitandorxornot_binAndOrXorNot()
```
    Bitwise operators, not aggregate functions!
  - bitandorxornot_operator
```
public void bitandorxornot_operator()
```
    Binary bitwise operators, not aggregate functions!
  - bitAndOr
```
public void bitAndOr()
```
    These are aggregate functions taking one argument!
  - everyAny
```
public void everyAny()
```
    These are aggregate functions taking one argument!
  - everyAny_boolAndOr
```
public void everyAny_boolAndOr()
```
    These are aggregate functions taking one argument, for databases that can directly aggregate both boolean columns and predicates!
  - everyAny_sumCase
```
public void everyAny_sumCase(boolean supportsPredicateAsExpression)
```
    These are aggregate functions taking one argument, for databases that have to emulate the boolean aggregation functions using sum() and case.
  - everyAny_minMaxIif
```
public void everyAny_minMaxIif()
```
    These are aggregate functions taking one argument, for SQL Server.
  - everyAny_minMaxCase
```
public void everyAny_minMaxCase()
```
    These are aggregate functions taking one argument, for Oracle and Sybase.
  - yearMonthDay
```
public void yearMonthDay()
```
    Note that we include these for completeness, but since their names collide with the HQL abbreviations for extract(), they can't actually be called from HQL.
  - hourMinuteSecond
```
public void hourMinuteSecond()
```
    Note that we include these for completeness, but since their names collide with the HQL abbreviations for extract(), they can't actually be called from HQL.
  - dayofweekmonthyear
```
public void dayofweekmonthyear()
```
  - dayOfWeekMonthYear
```
public void dayOfWeekMonthYear()
```
  - daynameMonthname
```
public void daynameMonthname()
```
  - weekQuarter
```
public void weekQuarter()
```
  - lastDay
```
public void lastDay()
```
  - lastDay_eomonth
```
public void lastDay_eomonth()
```
  - ceiling_ceil
```
public void ceiling_ceil()
```
  - toCharNumberDateTimestamp
```
public void toCharNumberDateTimestamp()
```
  - dateTimeTimestamp
```
public void dateTimeTimestamp()
```
  - timestamp
```
public void timestamp()
```
  - time
```
public void time()
```
  - date
```
public void date()
```
  - utcDateTimeTimestamp
```
public void utcDateTimeTimestamp()
```
  - currentUtcdatetimetimestamp
```
public void currentUtcdatetimetimestamp()
```
  - week_weekofyear
```
public void week_weekofyear()
```
  - concat_pipeOperator
```
public void concat_pipeOperator()
```
    Almost every database
  - concat_pipeOperator
```
public void concat_pipeOperator(String clobPattern)
```
  - rownumRowid
```
public void rownumRowid()
```
    Oracle-style
  - rownum
```
public void rownum()
```
    H2/HSQL-style
  - rownumInstOrderbyGroupbyNum
```
public void rownumInstOrderbyGroupbyNum()
```
    CUBRID
  - makedateMaketime
```
public void makedateMaketime()
```
    MySQL/CUBRID
  - makeDateTimeTimestamp
```
public void makeDateTimeTimestamp()
```
    Postgres
  - sysdate
```
public void sysdate()
```
  - sysdateParens
```
public void sysdateParens()
```
    MySQL requires the parens in sysdate()
  - sysdateExplicitMicros
```
public void sysdateExplicitMicros()
```
    MySQL 5.7 precision defaults to seconds, but microseconds is better
  - systimestamp
```
public void systimestamp()
```
  - localtimeLocaltimestamp
```
public void localtimeLocaltimestamp()
```
  - trigonometry
```
public void trigonometry()
```
  - atan2_atn2
```
public void atan2_atn2()
```
    Transact-SQL atan2 is misspelled
  - coalesce
```
public void coalesce()
```
  - coalesce_value
```
public void coalesce_value()
```
    SAP DB
  - nullif
```
public void nullif()
```
  - length_characterLength
```
public void length_characterLength()
```
    ANSI SQL-style
  - length_characterLength_pattern
```
public void length_characterLength_pattern(String clobPattern)
```
  - characterLength_len
```
public void characterLength_len()
```
    Transact SQL-style
  - characterLength_length
```
public void characterLength_length(SqlAstNodeRenderingMode argumentRenderingMode)
```
    Oracle-style
  - characterLength_length
```
public void characterLength_length(String clobPattern)
```
  - octetLength
```
public void octetLength()
```
  - octetLength_pattern
```
public void octetLength_pattern(String pattern)
```
  - octetLength_pattern
```
public void octetLength_pattern(String pattern,
                                SqlAstNodeRenderingMode renderingMode)
```
  - octetLength_pattern
```
public void octetLength_pattern(String pattern,
                                String clobPattern)
```
  - bitLength
```
public void bitLength()
```
  - bitLength_pattern
```
public void bitLength_pattern(String pattern)
```
  - bitLength_pattern
```
public void bitLength_pattern(String pattern,
                              SqlAstNodeRenderingMode renderingMode)
```
  - bitLength_pattern
```
public void bitLength_pattern(String pattern,
                              String clobPattern)
```
  - position
```
public void position()
```
    ANSI-style
  - locate
```
public void locate()
```
  - locate_charindex
```
public void locate_charindex()
```
    Transact SQL-style
  - locate_positionSubstring
```
public void locate_positionSubstring()
```
    locate() in terms of ANSI position() and substring()
  - substringFromFor
```
public void substringFromFor()
```
    ANSI-style substring
  - substring
```
public void substring()
```
    Not the same as ANSI-style substring!
  - substring_substringLen
```
public void substring_substringLen()
```
    Transact SQL-style (3 required args)
  - substring_substr
```
public void substring_substr()
```
    Oracle, and many others
  - insert
```
public void insert()
```
  - insert_overlay
```
public void insert_overlay()
```
    Postgres
  - overlay
```
public void overlay()
```
    ANSI SQL form, supported by Postgres, HSQL
  - overlayLength_overlay
```
public void overlayLength_overlay(boolean withCodeUnits)
```
    For DB2 which has a broken implementation of overlay()
  - replace
```
public void replace()
```
  - replace_strReplace
```
public void replace_strReplace()
```
    Sybase
  - concat
```
public void concat()
```
  - lowerUpper
```
public void lowerUpper()
```
  - ascii
```
public void ascii()
```
    Very widely supported, but we don't treat this as a "standard" function because it's hard to emulate on any database that doesn't have it (e.g. Derby) and because, well, ASCII. For the same reason we don't consider chr()/char() as "standard".
  - char_chr
```
public void char_chr()
```
  - chr_char
```
public void chr_char()
```
  - datepartDatename
```
public void datepartDatename()
```
    Transact SQL-style
  - nowCurdateCurtime
```
public void nowCurdateCurtime()
```
  - leastGreatest
```
public void leastGreatest()
```
  - leastGreatest_minMax
```
public void leastGreatest_minMax()
```
  - leastGreatest_minMaxValue
```
public void leastGreatest_minMaxValue()
```
  - aggregates
```
public void aggregates(Dialect dialect,
                       SqlAstNodeRenderingMode inferenceArgumentRenderingMode)
```
  - avg_castingNonDoubleArguments
```
public void avg_castingNonDoubleArguments(Dialect dialect,
                                          SqlAstNodeRenderingMode inferenceArgumentRenderingMode)
```
  - listagg
```
public void listagg(String emptyWithinReplacement)
```
  - listagg_groupConcat
```
public void listagg_groupConcat()
```
  - listagg_list
```
public void listagg_list(String stringType)
```
  - listagg_stringAgg
```
public void listagg_stringAgg(String stringType)
```
  - listagg_stringAggWithinGroup
```
public void listagg_stringAggWithinGroup(String stringType)
```
  - inverseDistributionOrderedSetAggregates
```
public void inverseDistributionOrderedSetAggregates()
```
  - inverseDistributionOrderedSetAggregates_windowEmulation
```
public void inverseDistributionOrderedSetAggregates_windowEmulation()
```
  - hypotheticalOrderedSetAggregates
```
public void hypotheticalOrderedSetAggregates()
```
  - hypotheticalOrderedSetAggregates_windowEmulation
```
public void hypotheticalOrderedSetAggregates_windowEmulation()
```
  - windowFunctions
```
public void windowFunctions()
```
  - math
```
public void math()
```
  - mod_operator
```
public void mod_operator()
```
  - power_expLn
```
public void power_expLn()
```
  - round
```
public void round()
```
  - round_round
```
public void round_round()
```
    SQL Server
  - round_floor
```
public void round_floor()
```
    Derby (only works if the second arg is constant, as it almost always is)
  - round_roundFloor
```
public void round_roundFloor()
```
    PostgreSQL (only works if the second arg is constant, as it almost always is)
  - square
```
public void square()
```
  - cbrt
```
public void cbrt()
```
  - crc32
```
public void crc32()
```
  - sha1
```
public void sha1()
```
  - sha2
```
public void sha2()
```
  - sha
```
public void sha()
```
  - datediff
```
public void datediff()
```
    MySQL style, returns the number of days between two dates
  - adddateSubdateAddtimeSubtime
```
public void adddateSubdateAddtimeSubtime()
```
    MySQL style
  - addMonths
```
public void addMonths()
```
  - monthsBetween
```
public void monthsBetween()
```
  - daysBetween
```
public void daysBetween()
```
  - secondsBetween
```
public void secondsBetween()
```
  - yearsMonthsDaysHoursMinutesSecondsBetween
```
public void yearsMonthsDaysHoursMinutesSecondsBetween()
```
  - addYearsMonthsDaysHoursMinutesSeconds
```
public void addYearsMonthsDaysHoursMinutesSeconds()
```
  - format_formatdatetime
```
public void format_formatdatetime()
```
    H2-style (uses Java's SimpleDateFormat directly so no need to translate format)
  - format_toChar
```
public void format_toChar()
```
    Usually Oracle-style (except for Informix which quite close to MySQL-style)
    
    See Also:
    
    OracleDialect.datetimeFormat(java.lang.String, boolean, boolean)
  - format_dateFormat
```
public void format_dateFormat()
```
    MySQL-style (also Ingres)
    
    See Also:
    
    MySQLDialect.datetimeFormat(java.lang.String)
  - format_toVarchar
```
public void format_toVarchar()
```
    HANA's name for to_char() is still Oracle-style
    
    See Also:
    
    OracleDialect.datetimeFormat(java.lang.String, boolean, boolean)
  - collate
```
public void collate()
```
    Use the 'collate' operator which exists on at least Postgres, MySQL, Oracle, and SQL Server
  - collate_quoted
```
public void collate_quoted()
```
    HSQL requires quotes around certain collations
  - dateTrunc
```
public void dateTrunc()
```
    H2, DB2 and PostgreSQL native date_trunc() function
  - dateTrunc_datetrunc
```
public void dateTrunc_datetrunc()
```
    SQLServer native datetrunc() function
  - array
```
public void array()
```
    H2, HSQL array() constructor function
  - array_hsql
```
public void array_hsql()
```
    H2, HSQL array() constructor function
  - array_postgresql
```
public void array_postgresql()
```
    CockroachDB and PostgreSQL array() constructor function
  - array_spanner
```
public void array_spanner()
```
    Google Spanner array() constructor function
  - array_oracle
```
public void array_oracle()
```
    Oracle array() constructor function
  - arrayAggregate
```
public void arrayAggregate()
```
    H2, HSQL, CockroachDB and PostgreSQL array_agg() function
  - arrayAggregate_jsonArrayagg
```
public void arrayAggregate_jsonArrayagg()
```
    Oracle array_agg() function
  - arrayContains_h2
```
public void arrayContains_h2(int maximumArraySize)
```
    H2 array_contains() function
  - arrayContains_hsql
```
public void arrayContains_hsql()
```
    HSQL array_contains() function
  - arrayContains_postgresql
```
public void arrayContains_postgresql()
```
    CockroachDB and PostgreSQL array contains operator
  - arrayContains_oracle
```
public void arrayContains_oracle()
```
    Oracle array_contains() function
  - arrayOverlaps_h2
```
public void arrayOverlaps_h2(int maximumArraySize)
```
    H2 array_overlaps() function
  - arrayOverlaps_hsql
```
public void arrayOverlaps_hsql()
```
    HSQL array_overlaps() function
  - arrayOverlaps_postgresql
```
public void arrayOverlaps_postgresql()
```
    CockroachDB and PostgreSQL array overlaps operator
  - arrayOverlaps_oracle
```
public void arrayOverlaps_oracle()
```
    Oracle array_overlaps() function
  - arrayPosition_postgresql
```
public void arrayPosition_postgresql()
```
    CockroachDB and PostgreSQL array_position() function
  - arrayPosition_h2
```
public void arrayPosition_h2(int maximumArraySize)
```
    H2 array_position() function
  - arrayPosition_hsql
```
public void arrayPosition_hsql()
```
    HSQL array_position() function
  - arrayPosition_oracle
```
public void arrayPosition_oracle()
```
    Oracle array_position() function
  - arrayPositions_postgresql
```
public void arrayPositions_postgresql()
```
    CockroachDB and PostgreSQL array_positions() function
  - arrayPositions_h2
```
public void arrayPositions_h2(int maximumArraySize)
```
    H2 array_positions() function
  - arrayPositions_hsql
```
public void arrayPositions_hsql()
```
    HSQL array_positions() function
  - arrayPositions_oracle
```
public void arrayPositions_oracle()
```
    Oracle array_positions() function
  - arrayLength_cardinality
```
public void arrayLength_cardinality()
```
    H2, HSQLDB, CockroachDB and PostgreSQL array_length() function
  - arrayLength_oracle
```
public void arrayLength_oracle()
```
    Oracle array_length() function
  - arrayConcat_operator
```
public void arrayConcat_operator()
```
    H2 and HSQLDB array_concat() function
  - arrayConcat_postgresql
```
public void arrayConcat_postgresql()
```
    CockroachDB and PostgreSQL array_concat() function
  - arrayConcat_oracle
```
public void arrayConcat_oracle()
```
    Oracle array_concat() function
  - arrayPrepend_operator
```
public void arrayPrepend_operator()
```
    H2 and HSQLDB array_prepend() function
  - arrayPrepend_postgresql
```
public void arrayPrepend_postgresql()
```
    CockroachDB and PostgreSQL array_prepend() function
  - arrayPrepend_oracle
```
public void arrayPrepend_oracle()
```
    Oracle array_prepend() function
  - arrayAppend_operator
```
public void arrayAppend_operator()
```
    H2 and HSQLDB array_append() function
  - arrayAppend_postgresql
```
public void arrayAppend_postgresql()
```
    CockroachDB and PostgreSQL array_append() function
  - arrayAppend_oracle
```
public void arrayAppend_oracle()
```
    Oracle array_append() function
  - arrayGet_h2
```
public void arrayGet_h2()
```
    H2 array_get() function via bracket syntax
  - arrayGet_bracket
```
public void arrayGet_bracket()
```
    CockroachDB and PostgreSQL array_get() function via bracket syntax
  - arrayGet_unnest
```
public void arrayGet_unnest()
```
    HSQL array_get() function
  - arrayGet_oracle
```
public void arrayGet_oracle()
```
    Oracle array_get() function
  - arraySet_h2
```
public void arraySet_h2(int maximumArraySize)
```
    H2 array_set() function
  - arraySet_hsql
```
public void arraySet_hsql()
```
    HSQL array_set() function
  - arraySet_unnest
```
public void arraySet_unnest()
```
    CockroachDB and PostgreSQL array_set() function
  - arraySet_oracle
```
public void arraySet_oracle()
```
    Oracle array_set() function
  - arrayRemove
```
public void arrayRemove()
```
    CockroachDB and PostgreSQL array_remove() function
  - arrayRemove_h2
```
public void arrayRemove_h2(int maximumArraySize)
```
    H2 array_remove() function
  - arrayRemove_hsql
```
public void arrayRemove_hsql()
```
    HSQL array_remove() function
  - arrayRemove_oracle
```
public void arrayRemove_oracle()
```
    Oracle array_remove() function
  - arrayRemoveIndex_h2
```
public void arrayRemoveIndex_h2(int maximumArraySize)
```
    H2 array_remove_index() function
  - arrayRemoveIndex_unnest
```
public void arrayRemoveIndex_unnest(boolean castEmptyArrayLiteral)
```
    HSQL, CockroachDB and PostgreSQL array_remove_index() function
  - arrayRemoveIndex_oracle
```
public void arrayRemoveIndex_oracle()
```
    Oracle array_remove_index() function
  - arraySlice
```
public void arraySlice()
```
    H2 array_slice() function
  - arraySlice_unnest
```
public void arraySlice_unnest()
```
    HSQL array_slice() function
  - arraySlice_operator
```
public void arraySlice_operator()
```
    CockroachDB and PostgreSQL array_slice() function
  - arraySlice_oracle
```
public void arraySlice_oracle()
```
    Oracle array_slice() function
  - arrayReplace_h2
```
public void arrayReplace_h2(int maximumArraySize)
```
    H2 array_replace() function
  - arrayReplace_unnest
```
public void arrayReplace_unnest()
```
    HSQL array_replace() function
  - arrayReplace
```
public void arrayReplace()
```
    CockroachDB and PostgreSQL array_replace() function
  - arrayReplace_oracle
```
public void arrayReplace_oracle()
```
    Oracle array_replace() function
  - arrayTrim_trim_array
```
public void arrayTrim_trim_array()
```
    H2, HSQLDB, CockroachDB and PostgreSQL array_trim() function
  - arrayTrim_unnest
```
public void arrayTrim_unnest()
```
    PostgreSQL array_trim() emulation for versions before 14
  - arrayTrim_oracle
```
public void arrayTrim_oracle()
```
    Oracle array_trim() function
  - arrayFill_h2
```
public void arrayFill_h2()
```
    H2 array_fill() function
  - arrayFill_hsql
```
public void arrayFill_hsql()
```
    HSQLDB array_fill() function
  - arrayFill_postgresql
```
public void arrayFill_postgresql()
```
    PostgreSQL array_fill() function
  - arrayFill_cockroachdb
```
public void arrayFill_cockroachdb()
```
    Cockroach array_fill() function
  - arrayFill_oracle
```
public void arrayFill_oracle()
```
    Oracle array_fill() function
  - arrayToString_h2
```
public void arrayToString_h2(int maximumArraySize)
```
    H2 array_to_string() function
  - arrayToString_hsql
```
public void arrayToString_hsql()
```
    HSQL array_to_string() function
  - arrayToString_postgresql
```
public void arrayToString_postgresql()
```
    CockroachDB and PostgreSQL array_to_string() function
  - arrayToString_oracle
```
public void arrayToString_oracle()
```
    Oracle array_to_string() function

Class CommonFunctionFactory

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CommonFunctionFactory

Method Detail

cot

log

log_ln

log_log

log_loglog

ln_log

log10

log10_log

log2

radians

radians_acos

degrees

degrees_acos

sinh

sinh_exp

cosh

cosh_exp

tanh

tanh_exp

moreHyperbolic

trunc

trunc_dateTrunc

trunc_dateTrunc_trunc

trunc_truncate

trunc_round_datetrunc

trunc_floor

trunc_roundMode

rand

median

median_percentileCont

median_percentileCont_castDouble

stddev

variance

stddevPopSamp

varPopSamp

covarPopSamp

corr

regrLinearRegressionAggregates

varianceSamp

varSamp_sumCount

stddevSamp_sumCount

stddevPopSamp_stdevp

varPopSamp_varp

pi

pi_acos

soundex

trim2

trim1

pad

pad_space

pad_replicate

pad_repeat

pad_fill

reverse

space

repeat

repeat_rpad

leftRight

leftRight_substr

leftRight_substrLength

repeat_replicate

md5

initcap

instr

substr

translate

bitand

bitor

bitxor

bitnot

bitandorxornot_bitAndOrXorNot

bitandorxornot_binAndOrXorNot

bitandorxornot_operator