JdbcDialectImpl (Mondrian OLAP Engine, version TRUNK-SNAPSHOT)

java.lang.Object
- mondrian.spi.impl.JdbcDialectImpl

All Implemented Interfaces:

Dialect

Direct Known Subclasses:

AccessDialect, Db2Dialect, DerbyDialect, FirebirdDialect, HiveDialect, HsqldbDialect, InformixDialect, IngresDialect, InterbaseDialect, LucidDbDialect, MicrosoftSqlServerDialect, MonetDbDialect, MySqlDialect, NeoviewDialect, OracleDialect, PostgreSqlDialect, SybaseDialect, TeradataDialect, VerticaDialect
```
public class JdbcDialectImpl
extends Object
implements Dialect
```
Implementation of Dialect based on a JDBC connection and metadata.
If you are writing a class for a specific database dialect, we recommend that you use this as a base class, so your dialect class will be forwards-compatible. If methods are added to Dialect in future revisions, default implementations of those methods will be added to this class.

Mondrian uses JdbcDialectImpl as a fallback if it cannot find a more specific dialect. JdbcDialectImpl reads properties from the JDBC driver's metadata, so can deduce some of the dialect's behavior.

Nested Class Summary
- Nested classes/interfaces inherited from interface mondrian.spi.Dialect
  Dialect.DatabaseProduct, Dialect.Datatype

Field Summary

Fields
Modifier and Type	Field and Description
`protected Dialect.DatabaseProduct`	`databaseProduct` Major database product (or null if product is not a common one)
`protected boolean`	`permitsSelectNotInGroupBy` Indicates whether the database allows selection of columns not listed in the group by clause.
`protected String`	`productVersion` Product version per JDBC driver.

Constructor Summary

Constructors
Constructor and Description

JdbcDialectImpl()

JdbcDialectImpl(Connection connection)
Creates a JdbcDialectImpl.

Constructors
Constructor and Description
`JdbcDialectImpl()`
`JdbcDialectImpl(Connection connection)` Creates a JdbcDialectImpl.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`allowsAs()` Returns whether the SQL dialect allows "AS" in the FROM clause.
`boolean`	`allowsCompoundCountDistinct()` Returns whether this Dialect allows multiple arguments to the `COUNT(DISTINCT ...) aggregate function, for example SELECT COUNT(DISTINCT x, y) FROM t`
`boolean`	`allowsCountDistinct()` Returns whether this Dialect supports distinct aggregations.
`boolean`	`allowsDdl()` Returns whether this dialect supports common SQL Data Definition Language (DDL) statements such as `CREATE TABLE` and `DROP INDEX`.
`boolean`	`allowsDialectSharing()` Returns whether this Dialect object can be used for all connections from the same data source.
`boolean`	`allowsFromQuery()` Returns whether this Dialect allows a subquery in the from clause, for example `SELECT * FROM (SELECT * FROM t) AS x`
`boolean`	`allowsJoinOn()` Returns whether this dialect supports "ANSI-style JOIN syntax", `FROM leftTable JOIN rightTable ON conditon`.
`boolean`	`allowsMultipleCountDistinct()` Returns whether this Dialect supports more than one distinct aggregation in the same query.
`boolean`	`allowsMultipleDistinctSqlMeasures()` Returns whether this Dialect has performant support of distinct SQL measures in the same query.
`boolean`	`allowsOrderByAlias()` Returns true if aliases defined in the SELECT clause can be used as expressions in the ORDER BY clause.
`boolean`	`allowsRegularExpressionInWhereClause()` Informs Mondrian if the dialect supports regular expressions when creating the 'where' or the 'having' clause.
`boolean`	`allowsSelectNotInGroupBy()` Returns whether the database currently permits queries to include in the SELECT clause expressions that are not listed in the GROUP BY clause.
`void`	`appendHintsAfterFromClause(StringBuilder buf, Map<String,String> hints)` Assembles and returns a string containing any hints that should be appended after the FROM clause in a SELECT statement, based on any hints provided.
`String`	`caseWhenElse(String cond, String thenExpr, String elseExpr)` Generates a conditional statement in this dialect's syntax.
`protected List<StatisticsProvider>`	`computeStatisticsProviders()`
`protected String`	`deduceIdentifierQuoteString(DatabaseMetaData databaseMetaData)`
`protected int`	`deduceMaxColumnNameLength(DatabaseMetaData databaseMetaData)`
`protected String`	`deduceProductName(DatabaseMetaData databaseMetaData)`
`protected String`	`deduceProductVersion(DatabaseMetaData databaseMetaData)`
`protected boolean`	`deduceReadOnly(DatabaseMetaData databaseMetaData)`
`protected Set<List<Integer>>`	`deduceSupportedResultSetStyles(DatabaseMetaData databaseMetaData)`
`protected boolean`	`deduceSupportsSelectNotInGroupBy(Connection conn)` Detects whether the database is configured to permit queries that include columns in the SELECT that are not also in the GROUP BY.
`String`	`generateCountExpression(String exp)` Some databases, like Greenplum, don't include nulls as part of the results of a COUNT sql call.
`String`	`generateInline(List<String> columnNames, List<String> columnTypes, List<String[]> valueList)` Generates a SQL statement to represent an inline dataset.
`String`	`generateInlineForAnsi(String alias, List<String> columnNames, List<String> columnTypes, List<String[]> valueList, boolean cast)` Generates inline values list using ANSI 'VALUES' syntax.
`protected String`	`generateInlineGeneric(List<String> columnNames, List<String> columnTypes, List<String[]> valueList, String fromClause, boolean cast)` Generic algorithm to generate inline values list, using an optional FROM clause, specified by the caller of this method, appropriate to the dialect of SQL.
`protected String`	`generateOrderByNulls(String expr, boolean ascending, boolean collateNullsLast)` Generates SQL to force null values to collate last.
`protected String`	`generateOrderByNullsAnsi(String expr, boolean ascending, boolean collateNullsLast)` Implementation for the `generateOrderByNulls(java.lang.String, boolean, boolean)` method that uses the ANSI syntax "expr direction NULLS LAST" and "expr direction NULLS FIRST".
`String`	`generateOrderItem(String expr, boolean nullable, boolean ascending, boolean collateNullsLast)` Generates an item for an ORDER BY clause, sorting in the required direction, and ensuring that NULL values collate either before or after all non-NULL values, depending on the `collateNullsLast` parameter.
`String`	`generateRegularExpression(String source, String javaRegExp)` Must generate a String representing a regular expression match operation between a string literal and a Java regular expression.
`Dialect.DatabaseProduct`	`getDatabaseProduct()` Returns the database for this Dialect, or `Dialect.DatabaseProduct.UNKNOWN` if the database is not a common database.
`int`	`getMaxColumnNameLength()` Returns the maximum length of the name of a database column or query alias allowed by this dialect.
`static Dialect.DatabaseProduct`	`getProduct(String productName, String productVersion)` Converts a product name and version (per the JDBC driver) into a product enumeration.
`String`	`getQuoteIdentifierString()` Returns the character which is used to quote identifiers, or null if quoting is not supported.
`List<StatisticsProvider>`	`getStatisticsProviders()` Returns a list of statistics providers for this dialect.
`SqlStatement.Type`	`getType(ResultSetMetaData metaData, int columnIndex)` Chooses the most appropriate type for accessing the values of a column in a result set for a dialect.
`protected static boolean`	`isDatabase(Dialect.DatabaseProduct databaseProduct, Connection connection)` Helper method to determine if a connection would work with a given database product.
`(package private) void`	`logTypeInfo(ResultSetMetaData metaData, int columnIndex, SqlStatement.Type internalType)`
`boolean`	`needsExponent(Object value, String valueString)` If Double values need to include additional exponent in its string represenation.
`void`	`quote(StringBuilder buf, Object value, Dialect.Datatype datatype)` Appends to a buffer a value quoted for its type.
`void`	`quoteBooleanLiteral(StringBuilder buf, String value)` Appends to a buffer a boolean literal.
`void`	`quoteDateLiteral(StringBuilder buf, String value)` Appends to a buffer a date literal.
`protected void`	`quoteDateLiteral(StringBuilder buf, String value, Date date)` Helper method for `quoteDateLiteral(StringBuilder, String)`.
`String`	`quoteIdentifier(String val)` Encloses an identifier in quotation marks appropriate for this Dialect.
`void`	`quoteIdentifier(StringBuilder buf, String... names)` Appends to a buffer a list of identifiers, quoted appropriately for this Dialect.
`String`	`quoteIdentifier(String qual, String name)` Encloses an identifier in quotation marks appropriate for the current SQL dialect.
`void`	`quoteIdentifier(String val, StringBuilder buf)` Appends to a buffer an identifier, quoted appropriately for this Dialect.
`void`	`quoteNumericLiteral(StringBuilder buf, String value)` Appends to a buffer a numeric literal.
`void`	`quoteStringLiteral(StringBuilder buf, String s)` Appends to a buffer a single-quoted SQL string.
`void`	`quoteTimeLiteral(StringBuilder buf, String value)` Appends to a buffer a time literal.
`void`	`quoteTimestampLiteral(StringBuilder buf, String value)` Appends to a buffer a timestamp literal.
`boolean`	`requiresAliasForFromQuery()` Returns whether this Dialect requires subqueries in the FROM clause to have an alias.
`boolean`	`requiresGroupByAlias()` Returns true if this Dialect can include expressions in the GROUP BY clause only by adding an expression to the SELECT clause and using its alias.
`boolean`	`requiresHavingAlias()` Returns true if this Dialect can include expressions in the HAVING clause only by adding an expression to the SELECT clause and using its alias.
`boolean`	`requiresOrderByAlias()` Returns true if this Dialect can include expressions in the ORDER BY clause only by adding an expression to the SELECT clause and using its alias.
`boolean`	`requiresUnionOrderByExprToBeInSelectClause()` Returns true if this dialect allows an expression in the ORDER BY clause of a UNION (or other set operation) query only if it occurs in the SELECT clause.
`boolean`	`requiresUnionOrderByOrdinal()` Returns true if this dialect allows only integers in the ORDER BY clause of a UNION (or other set operation) query.
`boolean`	`supportsGroupByExpressions()` Returns whether this Dialect supports expressions in the GROUP BY clause.
`boolean`	`supportsGroupingSets()` Returns whether this Dialect allows the GROUPING SETS construct in the GROUP BY clause.
`boolean`	`supportsMultiValueInExpr()` Returns true if this dialect supports multi-value IN expressions.
`boolean`	`supportsResultSetConcurrency(int type, int concurrency)` Returns whether this Dialect supports the given concurrency type in combination with the given result set type.
`boolean`	`supportsUnlimitedValueList()` Returns whether this Dialect places no limit on the number of rows which can appear as elements of an IN or VALUES expression.
`String`	`toString()`
`String`	`toUpper(String expr)` Converts an expression to upper case.

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

- Field Detail
  - productVersion
```
protected final String productVersion
```
    Product version per JDBC driver.
  - permitsSelectNotInGroupBy
```
protected boolean permitsSelectNotInGroupBy
```
    Indicates whether the database allows selection of columns not listed in the group by clause.
  - databaseProduct
```
protected final Dialect.DatabaseProduct databaseProduct
```
    Major database product (or null if product is not a common one)
- Constructor Detail
  - JdbcDialectImpl
```
public JdbcDialectImpl(Connection connection)
                throws SQLException
```
    Creates a JdbcDialectImpl.
    To prevent connection leaks, this constructor does not hold a reference to the connection after the call returns. It makes a copy of everything useful during the call. Derived classes must do the same.
    
    Throws:
    
    SQLException - on error
    Parameters:
    connection - Connection
  - JdbcDialectImpl
```
public JdbcDialectImpl()
```
- Method Detail
  - getDatabaseProduct
```
public Dialect.DatabaseProduct getDatabaseProduct()
```
    Description copied from interface: Dialect
    
    Returns the database for this Dialect, or Dialect.DatabaseProduct.UNKNOWN if the database is not a common database.
    
    Specified by:
    
    getDatabaseProduct in interface Dialect
    
    Returns:
    Database
  - appendHintsAfterFromClause
```
public void appendHintsAfterFromClause(StringBuilder buf,
                              Map<String,String> hints)
```
    Description copied from interface: Dialect
    
    Assembles and returns a string containing any hints that should be appended after the FROM clause in a SELECT statement, based on any hints provided. Any unrecognized or unsupported hints will be ignored.
    
    Specified by:
    
    appendHintsAfterFromClause in interface Dialect
    
    Parameters:
    buf - The Stringbuffer to which the dialect-specific syntax for any relevant table hints may be appended. Must not be null.
    hints - A map of table hints provided in the schema definition
  - allowsDialectSharing
```
public boolean allowsDialectSharing()
```
    Description copied from interface: Dialect
    
    Returns whether this Dialect object can be used for all connections from the same data source.
    The default implementation returns true, and this allows dialects to be cached and reused in environments where connections are allocated from a pool based on the same data source.
    
    Data sources are deemed 'equal' by the same criteria used by Java collections, namely the Object.equals(Object) and Object.hashCode() methods.
    
    Specified by:
    
    allowsDialectSharing in interface Dialect
    
    Returns:
    Whether this dialect can be used for other connections created from the same data source
    See Also:
    DialectFactory.createDialect(javax.sql.DataSource, java.sql.Connection)
  - deduceMaxColumnNameLength
```
protected int deduceMaxColumnNameLength(DatabaseMetaData databaseMetaData)
```
  - deduceReadOnly
```
protected boolean deduceReadOnly(DatabaseMetaData databaseMetaData)
```
  - deduceProductName
```
protected String deduceProductName(DatabaseMetaData databaseMetaData)
```
  - deduceIdentifierQuoteString
```
protected String deduceIdentifierQuoteString(DatabaseMetaData databaseMetaData)
```
  - deduceProductVersion
```
protected String deduceProductVersion(DatabaseMetaData databaseMetaData)
```
  - deduceSupportedResultSetStyles
```
protected Set<List<Integer>> deduceSupportedResultSetStyles(DatabaseMetaData databaseMetaData)
```
  - deduceSupportsSelectNotInGroupBy
```
protected boolean deduceSupportsSelectNotInGroupBy(Connection conn)
                                            throws SQLException
```
    Detects whether the database is configured to permit queries that include columns in the SELECT that are not also in the GROUP BY. MySQL is an example of one that does, though this is configurable.
    
    The expectation is that this will not change while Mondrian is running, though some databases (MySQL) allow changing it on the fly.
    
    Throws:
    
    SQLException - on error
    Parameters:
    conn - The database connection
    
    Returns:
    Whether the feature is enabled.
  - toUpper
```
public String toUpper(String expr)
```
    Description copied from interface: Dialect
    
    Converts an expression to upper case.
    For example, for MySQL, toUpper("foo.bar") returns "UPPER(foo.bar)".
    
    Specified by:
    
    toUpper in interface Dialect
    
    Parameters:
    expr - SQL expression
    
    Returns:
    SQL syntax that converts expr into upper case.
  - caseWhenElse
```
public String caseWhenElse(String cond,
                  String thenExpr,
                  String elseExpr)
```
    Description copied from interface: Dialect
    
    Generates a conditional statement in this dialect's syntax.
    For example, caseWhenElse("b", "1", "0") returns "case when b then 1 else 0 end" on Oracle, "Iif(b, 1, 0)" on Access.
    
    Specified by:
    
    caseWhenElse in interface Dialect
    
    Parameters:
    cond - Predicate expression
    thenExpr - Expression if condition is true
    elseExpr - Expression if condition is false
    
    Returns:
    Conditional expression
  - quoteIdentifier
```
public String quoteIdentifier(String val)
```
    Description copied from interface: Dialect
    
    Encloses an identifier in quotation marks appropriate for this Dialect.
    For example, quoteIdentifier("emp") yields a string containing "emp" in Oracle, and a string containing [emp] in Access.
    
    Specified by:
    
    quoteIdentifier in interface Dialect
    
    Parameters:
    val - Identifier
    
    Returns:
    Quoted identifier
  - quoteIdentifier
```
public void quoteIdentifier(String val,
                   StringBuilder buf)
```
    Description copied from interface: Dialect
    
    Appends to a buffer an identifier, quoted appropriately for this Dialect.
    
    Specified by:
    
    quoteIdentifier in interface Dialect
    
    Parameters:
    val - identifier to quote (must not be null).
    buf - Buffer
  - quoteIdentifier
```
public String quoteIdentifier(String qual,
                     String name)
```
    Description copied from interface: Dialect
    
    Encloses an identifier in quotation marks appropriate for the current SQL dialect. For example, in Oracle, where the identifiers are quoted using double-quotes, quoteIdentifier("schema","table") yields a string containing "schema"."table".
    
    Specified by:
    
    quoteIdentifier in interface Dialect
    
    Parameters:
    qual - Qualifier. If it is not null, "qual". is prepended.
    name - Name to be quoted.
    
    Returns:
    Quoted identifier
  - quoteIdentifier
```
public void quoteIdentifier(StringBuilder buf,
                   String... names)
```
    Description copied from interface: Dialect
    
    Appends to a buffer a list of identifiers, quoted appropriately for this Dialect.
    Names in the list may be null, but there must be at least one non-null name in the list.
    
    Specified by:
    
    quoteIdentifier in interface Dialect
    
    Parameters:
    buf - Buffer
    names - List of names to be quoted
  - getQuoteIdentifierString
```
public String getQuoteIdentifierString()
```
    Description copied from interface: Dialect
    
    Returns the character which is used to quote identifiers, or null if quoting is not supported.
    
    Specified by:
    
    getQuoteIdentifierString in interface Dialect
    
    Returns:
    identifier quote
  - quoteStringLiteral
```
public void quoteStringLiteral(StringBuilder buf,
                      String s)
```
    Description copied from interface: Dialect
    
    Appends to a buffer a single-quoted SQL string.
    For example, in the default dialect, quoteStringLiteral(buf, "Can't") appends "'Can''t'" to buf.
    
    Specified by:
    
    quoteStringLiteral in interface Dialect
    
    Parameters:
    buf - Buffer to append to
    s - Literal
  - quoteNumericLiteral
```
public void quoteNumericLiteral(StringBuilder buf,
                       String value)
```
    Description copied from interface: Dialect
    
    Appends to a buffer a numeric literal.
    In the default dialect, numeric literals are printed as is.
    
    Specified by:
    
    quoteNumericLiteral in interface Dialect
    
    Parameters:
    buf - Buffer to append to
    value - Literal
  - quoteBooleanLiteral
```
public void quoteBooleanLiteral(StringBuilder buf,
                       String value)
```
    Description copied from interface: Dialect
    
    Appends to a buffer a boolean literal.
    In the default dialect, boolean literals are printed as is.
    
    Specified by:
    
    quoteBooleanLiteral in interface Dialect
    
    Parameters:
    buf - Buffer to append to
    value - Literal
  - quoteDateLiteral
```
public void quoteDateLiteral(StringBuilder buf,
                    String value)
```
    Description copied from interface: Dialect
    
    Appends to a buffer a date literal.
    For example, in the default dialect, quoteStringLiteral(buf, "1969-03-17") appends DATE '1969-03-17'.
    
    Specified by:
    
    quoteDateLiteral in interface Dialect
    
    Parameters:
    buf - Buffer to append to
    value - Literal
  - quoteDateLiteral
```
protected void quoteDateLiteral(StringBuilder buf,
                    String value,
                    Date date)
```
    Helper method for quoteDateLiteral(StringBuilder, String).
    
    Parameters:
    buf - Buffer to append to
    value - Value as string
    date - Value as date
  - quoteTimeLiteral
```
public void quoteTimeLiteral(StringBuilder buf,
                    String value)
```
    Description copied from interface: Dialect
    
    Appends to a buffer a time literal.
    For example, in the default dialect, quoteStringLiteral(buf, "12:34:56") appends TIME '12:34:56'.
    
    Specified by:
    
    quoteTimeLiteral in interface Dialect
    
    Parameters:
    buf - Buffer to append to
    value - Literal
  - quoteTimestampLiteral
```
public void quoteTimestampLiteral(StringBuilder buf,
                         String value)
```
    Description copied from interface: Dialect
    
    Appends to a buffer a timestamp literal.
    For example, in the default dialect, quoteStringLiteral(buf, "1969-03-17 12:34:56") appends TIMESTAMP '1969-03-17 12:34:56'.
    
    Specified by:
    
    quoteTimestampLiteral in interface Dialect
    
    Parameters:
    buf - Buffer to append to
    value - Literal
  - requiresAliasForFromQuery
```
public boolean requiresAliasForFromQuery()
```
    Description copied from interface: Dialect
    
    Returns whether this Dialect requires subqueries in the FROM clause to have an alias.
    
    Specified by:
    
    requiresAliasForFromQuery in interface Dialect
    
    Returns:
    whether dialewct requires subqueries to have an alias
    See Also:
    Dialect.allowsFromQuery()
  - allowsAs
```
public boolean allowsAs()
```
    Description copied from interface: Dialect
    
    Returns whether the SQL dialect allows "AS" in the FROM clause. If so, "SELECT * FROM t AS alias" is a valid query.
    
    Specified by:
    
    allowsAs in interface Dialect
    
    Returns:
    whether dialect allows AS in FROM clause
  - allowsFromQuery
```
public boolean allowsFromQuery()
```
    Description copied from interface: Dialect
    
    Returns whether this Dialect allows a subquery in the from clause, for example
    SELECT * FROM (SELECT * FROM t) AS x
    
    Specified by:
    
    allowsFromQuery in interface Dialect
    
    Returns:
    whether Dialect allows subquery in FROM clause
    See Also:
    Dialect.requiresAliasForFromQuery()
  - allowsCompoundCountDistinct
```
public boolean allowsCompoundCountDistinct()
```
    Description copied from interface: Dialect
    
    Returns whether this Dialect allows multiple arguments to the COUNT(DISTINCT ...) aggregate function, for example SELECT COUNT(DISTINCT x, y) FROM t
    Specified by: allowsCompoundCountDistinct in interface Dialect Returns: whether Dialect allows multiple arguments to COUNT DISTINCT See Also: Dialect.allowsCountDistinct(), Dialect.allowsMultipleCountDistinct()
  allowsCountDistinct public boolean allowsCountDistinct() Description copied from interface: Dialect Returns whether this Dialect supports distinct aggregations. For example, Access does not allow select count(distinct x) from t Specified by: allowsCountDistinct in interface Dialect Returns: whether Dialect allows COUNT DISTINCT allowsMultipleCountDistinct public boolean allowsMultipleCountDistinct() Description copied from interface: Dialect Returns whether this Dialect supports more than one distinct aggregation in the same query. In Derby 10.1, select couunt(distinct x) from t is OK, but select couunt(distinct x), count(distinct y) from t gives "Multiple DISTINCT aggregates are not supported at this time." Specified by: allowsMultipleCountDistinct in interface Dialect Returns: whether this Dialect supports more than one distinct aggregation in the same query allowsMultipleDistinctSqlMeasures public boolean allowsMultipleDistinctSqlMeasures() Description copied from interface: Dialect Returns whether this Dialect has performant support of distinct SQL measures in the same query. Specified by: allowsMultipleDistinctSqlMeasures in interface Dialect Returns: whether this dialect supports multiple count(distinct subquery) measures in one query. generateInline public String generateInline(List<String> columnNames, List<String> columnTypes, List<String[]> valueList) Description copied from interface: Dialect Generates a SQL statement to represent an inline dataset. For example, for Oracle, generates SELECT 1 AS FOO, 'a' AS BAR FROM dual UNION ALL SELECT 2 AS FOO, 'b' AS BAR FROM dual For ANSI SQL, generates: VALUES (1, 'a'), (2, 'b') Specified by: generateInline in interface Dialect Parameters: columnNames - List of column names columnTypes - List of column types ("String" or "Numeric") valueList - List of rows values Returns: SQL string generateInlineGeneric protected String generateInlineGeneric(List<String> columnNames, List<String> columnTypes, List<String[]> valueList, String fromClause, boolean cast) Generic algorithm to generate inline values list, using an optional FROM clause, specified by the caller of this method, appropriate to the dialect of SQL. Parameters: columnNames - Column names columnTypes - Column types valueList - List rows fromClause - FROM clause, or null cast - Whether to cast the values in the first row Returns: Expression that returns the given values generateInlineForAnsi public String generateInlineForAnsi(String alias, List<String> columnNames, List<String> columnTypes, List<String[]> valueList, boolean cast) Generates inline values list using ANSI 'VALUES' syntax. For example, SELECT * FROM (VALUES (1, 'a'), (2, 'b')) AS t(x, y) If NULL values are present, we use a CAST to ensure that they have the same type as other columns: SELECT * FROM (VALUES (1, 'a'), (2, CASE(NULL AS VARCHAR(1)))) AS t(x, y) This syntax is known to work on Derby, but not Oracle 10 or Access. Parameters: alias - Table alias columnNames - Column names columnTypes - Column types valueList - List rows cast - Whether to generate casts Returns: Expression that returns the given values needsExponent public boolean needsExponent(Object value, String valueString) Description copied from interface: Dialect If Double values need to include additional exponent in its string represenation. This is to make sure that Double literals will be interpreted as doubles by LucidDB. Specified by: needsExponent in interface Dialect Parameters: value - Double value to generate string for valueString - java string representation for this value. Returns: whether an additional exponent "E0" needs to be appended quote public void quote(StringBuilder buf, Object value, Dialect.Datatype datatype) Description copied from interface: Dialect Appends to a buffer a value quoted for its type. Specified by: quote in interface Dialect Parameters: buf - Buffer to append to value - Value datatype - Datatype of value allowsDdl public boolean allowsDdl() Description copied from interface: Dialect Returns whether this dialect supports common SQL Data Definition Language (DDL) statements such as CREATE TABLE and DROP INDEX. Access seems to allow DDL iff the .mdb file is writeable. Specified by: allowsDdl in interface Dialect Returns: whether this Dialect supports DDL See Also: DatabaseMetaData.isReadOnly() generateOrderItem public String generateOrderItem(String expr, boolean nullable, boolean ascending, boolean collateNullsLast) Description copied from interface: Dialect Generates an item for an ORDER BY clause, sorting in the required direction, and ensuring that NULL values collate either before or after all non-NULL values, depending on the collateNullsLast parameter. Specified by: generateOrderItem in interface Dialect Parameters: expr - Expression nullable - Whether expression may have NULL values ascending - Whether to sort expression ascending collateNullsLast - Whether the null values should be sorted first or last. Returns: Expression modified so that NULL values collate last generateOrderByNulls protected String generateOrderByNulls(String expr, boolean ascending, boolean collateNullsLast) Generates SQL to force null values to collate last. This default implementation makes use of the ANSI SQL 1999 CASE-WHEN-THEN-ELSE in conjunction with IS NULL syntax. The resulting SQL will look something like this: CASE WHEN "expr" IS NULL THEN 0 ELSE 1 END You can override this method for a particular database to use something more efficient, like ISNULL(). ANSI SQL provides the syntax "ASC/DESC NULLS LAST" and "ASC/DESC NULLS FIRST". If your database supports the ANSI syntax, implement this method by calling generateOrderByNullsAnsi(java.lang.String, boolean, boolean). This method is only called from generateOrderItem(String, boolean, boolean, boolean). Some dialects override that method and therefore never call this method. Parameters: expr - Expression. ascending - Whether ascending. collateNullsLast - Whether nulls should appear first or last. Returns: Expression to force null values to collate last or first. generateOrderByNullsAnsi protected final String generateOrderByNullsAnsi(String expr, boolean ascending, boolean collateNullsLast) Implementation for the generateOrderByNulls(java.lang.String, boolean, boolean) method that uses the ANSI syntax "expr direction NULLS LAST" and "expr direction NULLS FIRST". Parameters: expr - Expression ascending - Whether ascending collateNullsLast - Whether nulls should appear first or last. Returns: Expression "expr direction NULLS LAST" supportsGroupByExpressions public boolean supportsGroupByExpressions() Description copied from interface: Dialect Returns whether this Dialect supports expressions in the GROUP BY clause. Derby/Cloudscape and Infobright do not. Specified by: supportsGroupByExpressions in interface Dialect Returns: Whether this Dialect allows expressions in the GROUP BY clause allowsSelectNotInGroupBy public boolean allowsSelectNotInGroupBy() Description copied from interface: Dialect Returns whether the database currently permits queries to include in the SELECT clause expressions that are not listed in the GROUP BY clause. The SQL standard allows this if the database can deduce that the expression is functionally dependent on columns in the GROUP BY clause. For example, SELECT empno, first_name || ' ' || last_name FROM emps GROUP BY empno is valid because empno is the primary key of the emps table, and therefore all columns are dependent on it. For a given value of empno, first_name || ' ' || last_name has a unique value. Most databases do not, MySQL is an example of one that does (if the functioality is enabled). Specified by: allowsSelectNotInGroupBy in interface Dialect Returns: Whether this Dialect allows SELECT clauses to contain columns that are not in the GROUP BY clause allowsJoinOn public boolean allowsJoinOn() Description copied from interface: Dialect Returns whether this dialect supports "ANSI-style JOIN syntax", FROM leftTable JOIN rightTable ON conditon. Specified by: allowsJoinOn in interface Dialect Returns: Whether this dialect supports FROM-JOIN-ON syntax. supportsGroupingSets public boolean supportsGroupingSets() Description copied from interface: Dialect Returns whether this Dialect allows the GROUPING SETS construct in the GROUP BY clause. Currently Greenplum, IBM DB2, Oracle, and Teradata. Specified by: supportsGroupingSets in interface Dialect Returns: Whether this Dialect allows GROUPING SETS clause supportsUnlimitedValueList public boolean supportsUnlimitedValueList() Description copied from interface: Dialect Returns whether this Dialect places no limit on the number of rows which can appear as elements of an IN or VALUES expression. Specified by: supportsUnlimitedValueList in interface Dialect Returns: whether value list length is unlimited requiresGroupByAlias public boolean requiresGroupByAlias() Description copied from interface: Dialect Returns true if this Dialect can include expressions in the GROUP BY clause only by adding an expression to the SELECT clause and using its alias. For example, in such a dialect, SELECT x, x FROM t GROUP BY x would be illegal, but SELECT x AS a, x AS b FROM t ORDER BY a, b would be legal. Infobright is the only such dialect. Specified by: requiresGroupByAlias in interface Dialect Returns: Whether this Dialect can include expressions in the GROUP BY clause only by adding an expression to the SELECT clause and using its alias requiresOrderByAlias public boolean requiresOrderByAlias() Description copied from interface: Dialect Returns true if this Dialect can include expressions in the ORDER BY clause only by adding an expression to the SELECT clause and using its alias. For example, in such a dialect, SELECT x FROM t ORDER BY x + y would be illegal, but SELECT x, x + y AS z FROM t ORDER BY z would be legal. MySQL, DB2 and Ingres are examples of such dialects. Specified by: requiresOrderByAlias in interface Dialect Returns: Whether this Dialect can include expressions in the ORDER BY clause only by adding an expression to the SELECT clause and using its alias requiresHavingAlias public boolean requiresHavingAlias() Description copied from interface: Dialect Returns true if this Dialect can include expressions in the HAVING clause only by adding an expression to the SELECT clause and using its alias. For example, in such a dialect, SELECT CONCAT(x) as foo FROM t HAVING CONCAT(x) LIKE "%" would be illegal, but SELECT CONCAT(x) as foo FROM t HAVING foo LIKE "%" would be legal. MySQL is an example of such dialects. Specified by: requiresHavingAlias in interface Dialect Returns: Whether this Dialect can include expressions in the HAVING clause only by adding an expression to the SELECT clause and using its alias allowsOrderByAlias public boolean allowsOrderByAlias() Description copied from interface: Dialect Returns true if aliases defined in the SELECT clause can be used as expressions in the ORDER BY clause. For example, in such a dialect, SELECT x, x + y AS z FROM t ORDER BY z would be legal. MySQL, DB2 and Ingres are examples of dialects where this is true; Access is a dialect where this is false. Specified by: allowsOrderByAlias in interface Dialect Returns: Whether aliases defined in the SELECT clause can be used as expressions in the ORDER BY clause. requiresUnionOrderByOrdinal public boolean requiresUnionOrderByOrdinal() Description copied from interface: Dialect Returns true if this dialect allows only integers in the ORDER BY clause of a UNION (or other set operation) query. For example, SELECT x, y + z FROM t UNION ALL SELECT x, y + z FROM t ORDER BY 1, 2 is allowed but SELECT x, y, z FROM t UNION ALL SELECT x, y, z FROM t ORDER BY x is not. Teradata is an example of a dialect with this restriction. Specified by: requiresUnionOrderByOrdinal in interface Dialect Returns: whether this dialect allows only integers in the ORDER BY clause of a UNION (or other set operation) query requiresUnionOrderByExprToBeInSelectClause public boolean requiresUnionOrderByExprToBeInSelectClause() Description copied from interface: Dialect Returns true if this dialect allows an expression in the ORDER BY clause of a UNION (or other set operation) query only if it occurs in the SELECT clause. For example, SELECT x, y + z FROM t UNION ALL SELECT x, y + z FROM t ORDER BY y + z is allowed but SELECT x, y, z FROM t UNION ALL SELECT x, y, z FROM t ORDER BY y + z SELECT x, y, z FROM t ORDER BY y + z is not. Access is an example of a dialect with this restriction. Specified by: requiresUnionOrderByExprToBeInSelectClause in interface Dialect Returns: whether this dialect allows an expression in the ORDER BY clause of a UNION (or other set operation) query only if it occurs in the SELECT clause supportsMultiValueInExpr public boolean supportsMultiValueInExpr() Description copied from interface: Dialect Returns true if this dialect supports multi-value IN expressions. E.g., WHERE (col1, col2) IN ((val1a, val2a), (val1b, val2b)) Specified by: supportsMultiValueInExpr in interface Dialect Returns: true if the dialect supports multi-value IN expressions supportsResultSetConcurrency public boolean supportsResultSetConcurrency(int type, int concurrency) Description copied from interface: Dialect Returns whether this Dialect supports the given concurrency type in combination with the given result set type. The result is similar to DatabaseMetaData.supportsResultSetConcurrency(int, int), except that the JdbcOdbc bridge in JDK 1.6 overstates its abilities. See bug 1690406. Specified by: supportsResultSetConcurrency in interface Dialect Parameters: type - defined in ResultSet concurrency - type defined in ResultSet Returns: true if so; false otherwise toString public String toString() Overrides: toString in class Object getMaxColumnNameLength public int getMaxColumnNameLength() Description copied from interface: Dialect Returns the maximum length of the name of a database column or query alias allowed by this dialect. Specified by: getMaxColumnNameLength in interface Dialect Returns: maximum number of characters in a column name See Also: DatabaseMetaData.getMaxColumnNameLength() allowsRegularExpressionInWhereClause public boolean allowsRegularExpressionInWhereClause() Description copied from interface: Dialect Informs Mondrian if the dialect supports regular expressions when creating the 'where' or the 'having' clause. Specified by: allowsRegularExpressionInWhereClause in interface Dialect Returns: True if regular expressions are supported. generateCountExpression public String generateCountExpression(String exp) Description copied from interface: Dialect Some databases, like Greenplum, don't include nulls as part of the results of a COUNT sql call. This allows dialects to wrap the count expression in something before it is used in the query. Specified by: generateCountExpression in interface Dialect Parameters: exp - The expression to wrap. Returns: A valid expression to use for a count operation. generateRegularExpression public String generateRegularExpression(String source, String javaRegExp) Description copied from interface: Dialect Must generate a String representing a regular expression match operation between a string literal and a Java regular expression. The string literal might be a column identifier or some other identifier, but the implementation must presume that it is already escaped and fit for use. The regular expression is not escaped and must be adapted to the proper dialect rules. Postgres / Greenplum example: generateRegularExpression( "'foodmart'.'customer_name'", "(?i).*oo.*") -> 'foodmart'.'customer_name' ~ "(?i).*oo.*" Oracle example: generateRegularExpression( "'foodmart'.'customer_name'", ".*oo.*") -> REGEXP_LIKE('foodmart'.'customer_name', ".*oo.*") Dialects are allowed to return null if the dialect cannot convert that particular regular expression into something that the database would support. Specified by: generateRegularExpression in interface Dialect Parameters: source - A String identifying the column to match against. javaRegExp - A Java regular expression to match against. Returns: A dialect specific matching operation, or null if the dialect cannot convert that particular regular expression into something that the database would support. getStatisticsProviders public List<StatisticsProvider> getStatisticsProviders() Description copied from interface: Dialect Returns a list of statistics providers for this dialect. The default implementation looks for the value of the property mondrian.statistics.providers.PRODUCT where product is the current dialect's product name (for example "MYSQL"). If that property has no value, looks at the property mondrian.statistics.providers. The property value should be a comma-separated list of names of classes that implement the StatisticsProvider interface. For each statistic required, Mondrian will call the method each statistics provider in turn, until one of them returns a non-negative value. Specified by: getStatisticsProviders in interface Dialect getType public SqlStatement.Type getType(ResultSetMetaData metaData, int columnIndex) throws SQLException Description copied from interface: Dialect Chooses the most appropriate type for accessing the values of a column in a result set for a dialect. Dialect-specific nuances involving type representation should be encapsulated in implementing methods. For example, if a dialect has implicit rules involving scale or precision, they should be handled within this method so the client can simply retrieve the "best fit" SqlStatement.Type for the column. Specified by: getType in interface Dialect Throws: SQLException Parameters: metaData - Results set metadata columnIndex - Column ordinal (0-based) Returns: the most appropriate SqlStatement.Type for the column logTypeInfo void logTypeInfo(ResultSetMetaData metaData, int columnIndex, SqlStatement.Type internalType) throws SQLException Throws: SQLException computeStatisticsProviders protected List<StatisticsProvider> computeStatisticsProviders() getProduct public static Dialect.DatabaseProduct getProduct(String productName, String productVersion) Converts a product name and version (per the JDBC driver) into a product enumeration. Parameters: productName - Product name productVersion - Product version Returns: database product isDatabase protected static boolean isDatabase(Dialect.DatabaseProduct databaseProduct, Connection connection) Helper method to determine if a connection would work with a given database product. This can be used to differenciate between databases which use the same driver as others. It will first try to use DatabaseMetaData.getDatabaseProductName() and match the name of Dialect.DatabaseProduct passed as an argument. If that fails, it will try to execute select version(); and obtains some information directly from the server. Parameters: databaseProduct - Database product instance connection - SQL connection Returns: true if a match was found. false otherwise.

Class JdbcDialectImpl

Nested Class Summary

Nested classes/interfaces inherited from interface mondrian.spi.Dialect

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

productVersion

permitsSelectNotInGroupBy

databaseProduct

Constructor Detail

JdbcDialectImpl

JdbcDialectImpl

Method Detail

getDatabaseProduct

appendHintsAfterFromClause

allowsDialectSharing

deduceMaxColumnNameLength

deduceReadOnly

deduceProductName

deduceIdentifierQuoteString

deduceProductVersion

deduceSupportedResultSetStyles

deduceSupportsSelectNotInGroupBy

toUpper

caseWhenElse

quoteIdentifier

quoteIdentifier

quoteIdentifier

quoteIdentifier

getQuoteIdentifierString

quoteStringLiteral

quoteNumericLiteral

quoteBooleanLiteral

quoteDateLiteral

quoteDateLiteral

quoteTimeLiteral

quoteTimestampLiteral

requiresAliasForFromQuery

allowsAs

allowsFromQuery

allowsCompoundCountDistinct

allowsCountDistinct

allowsMultipleCountDistinct

allowsMultipleDistinctSqlMeasures

generateInline

generateInlineGeneric

generateInlineForAnsi

needsExponent

quote

allowsDdl

generateOrderItem

generateOrderByNulls

generateOrderByNullsAnsi

supportsGroupByExpressions

allowsSelectNotInGroupBy

allowsJoinOn

supportsGroupingSets

supportsUnlimitedValueList

requiresGroupByAlias

requiresOrderByAlias

requiresHavingAlias

allowsOrderByAlias

requiresUnionOrderByOrdinal

requiresUnionOrderByExprToBeInSelectClause

supportsMultiValueInExpr

supportsResultSetConcurrency

toString

getMaxColumnNameLength

allowsRegularExpressionInWhereClause

generateCountExpression

generateRegularExpression

getStatisticsProviders

getType

logTypeInfo

computeStatisticsProviders

getProduct

isDatabase