ERXSQLHelper (Project Wonder Reference Documentation)

java.lang.Object
- er.extensions.jdbc.ERXSQLHelper

Direct Known Subclasses:

ERXSQLHelper.DB2SQLHelper, ERXSQLHelper.DerbySQLHelper, ERXSQLHelper.FirebirdSQLHelper, ERXSQLHelper.FrontBaseSQLHelper, ERXSQLHelper.H2SQLHelper, ERXSQLHelper.MicrosoftSQLHelper, ERXSQLHelper.MySQLSQLHelper, ERXSQLHelper.NoSQLHelper, ERXSQLHelper.OpenBaseSQLHelper, ERXSQLHelper.OracleSQLHelper, ERXSQLHelper.PostgresqlSQLHelper
```
public class ERXSQLHelper
extends Object
```
ERXSQLHelper provides support for additional database-vender-specific operations that JDBCPlugIn does not cover. By default this will try to load the class er.extensions.ERXSQLHelper$DatabaseVendorSQLHelper. For instance, er.extensions.ERXSQLHelper$FrontBaseSQLHelper. If you want to change the helper that is used for a particular database vendor, then override FrontBase.SQLHelper, Oracle.SQLHelper, etc. Case is important (because the vendor name is prepended to the class name), and should match what your JDBCPlugIn.databaseProductName() returns.

Author:

mschrag

Properties
Name Description
databaseProductName.SQLHelper the class name of the SQLHelper for the database product name

Properties
Name	Description
`databaseProductName.SQLHelper`	the class name of the SQLHelper for the database product name

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ERXSQLHelper.ColumnIndex` IndexLimit represents the reference to a column for use in an index definition along with an optional limit.
`static interface`	`ERXSQLHelper.CustomTypes` custom JDBC types
`static class`	`ERXSQLHelper.DB2SQLHelper`
`static class`	`ERXSQLHelper.DerbySQLHelper`
`static class`	`ERXSQLHelper.EROracleSQLHelper`
`static class`	`ERXSQLHelper.FirebirdSQLHelper`
`static class`	`ERXSQLHelper.FrontBaseSQLHelper`
`static class`	`ERXSQLHelper.H2SQLHelper`
`static class`	`ERXSQLHelper.MicrosoftSQLHelper`
`static class`	`ERXSQLHelper.MySQLSQLHelper`
`static class`	`ERXSQLHelper.NoSQLHelper`
`static class`	`ERXSQLHelper.OpenBaseSQLHelper`
`static class`	`ERXSQLHelper.OracleSQLHelper`
`static class`	`ERXSQLHelper.PostgresqlSQLHelper`

Constructor Summary

Constructors
Constructor and Description

ERXSQLHelper()

Constructors
Constructor and Description
`ERXSQLHelper()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`_groupByOrHavingIndex(EOSQLExpression expression)` Returns the index in the expression's statement where group by and having clauses should be inserted.
`int`	`_orderByIndex(EOSQLExpression expression)` Returns the index in the expression's statement where order by clauses should be inserted.
`void`	`addGroupByClauseToExpression(EOEditingContext editingContext, EOFetchSpecification fetchSpec, EOSQLExpression expression)` Adds a group-by clause to the given SQL Expression based on the list of attributes defined in the given fetch spec.
`void`	`addGroupByClauseToExpression(NSArray<EOAttribute> attributes, EOSQLExpression expression)` Adds a group-by clause to the given SQL Expression based on the given list of attributes.
`void`	`addHavingCountClauseToExpression(NSSelector selector, int value, EOSQLExpression expression)` Adds a " having count(*) > x" clause to a group by expression.
`void`	`appendItemToListString(String itemString, StringBuffer listString)` Adds itemString to a comma-separated list.
`NSArray<EOAttribute>`	`attributesToFetchForEntity(EOFetchSpecification fetchSpec, EOEntity entity)` Returns the list of attributes to fetch for a fetch spec.
`protected boolean`	`canReliablyPerformDistinctWithSortOrderings()` Returns whether or not this database can always perform the a distinct operation when sort orderings are applied.
`protected ERXSQLHelper.ColumnIndex[]`	`columnIndexesFromColumnNames(String... columnNames)`
`NSMutableArray<String>`	`columnNamesFromColumnIndexes(ERXSQLHelper.ColumnIndex... columnIndexes)`
`protected char`	`commandSeparatorChar()` This is totally cheating ...
`protected String`	`commandSeparatorString()`
`protected Pattern`	`commentPattern()` Returns a pattern than matches only blank lines.
`String`	`createDependentSchemaSQLForEntities(NSArray<EOEntity> entities, EOAdaptor adaptor)` Generates table create statements for a set of entities, then finds all the entities that those entities depend on (in other models) and generates foreign key statements for those, so you can generate sql for cross-model.
`String`	`createIndexSQLForEntities(NSArray<EOEntity> entities)`
`String`	`createIndexSQLForEntities(NSArray<EOEntity> entities, NSArray<String> externalTypesToIgnore)`
`String`	`createSchemaSQLForEntitiesInDatabaseContext(NSArray<EOEntity> entities, EODatabaseContext databaseContext, boolean create, boolean drop)` creates SQL to create tables for the specified Entities.
`String`	`createSchemaSQLForEntitiesInModel(NSArray<EOEntity> entities, EOModel model)` Creates SQL to create tables for the specified Entities.
`String`	`createSchemaSQLForEntitiesInModelAndOptions(NSArray<EOEntity> entities, EOModel model, NSDictionary optionsCreate)` creates SQL to create tables for the specified Entities.
`String`	`createSchemaSQLForEntitiesInModelWithName(NSArray<EOEntity> entities, String modelName)` creates SQL to create tables for the specified Entities.
`String`	`createSchemaSQLForEntitiesInModelWithNameAndOptions(NSArray<EOEntity> entities, String modelName, NSDictionary optionsCreate)` creates SQL to create tables for the specified Entities.
`String`	`createSchemaSQLForEntitiesWithOptions(NSArray<EOEntity> entities, EOAdaptor adaptor, NSDictionary<String,String> optionsDictionary)` Creates the schema sql for a set of entities.
`String`	`createSchemaSQLForEntitiesWithOptions(NSArray<EOEntity> entities, EODatabaseContext databaseContext, NSDictionary<String,String> optionsCreate)` Creates the schema sql for a set of entities.
`String`	`customQueryExpressionHintAsString(Object hint)` Returns the custom query expression hint as a String.
`NSMutableDictionary<String,String>`	`defaultOptionDictionary(boolean create, boolean drop)` Creates an option dictionary to use with the other methods
`String`	`externalTypeForJDBCType(JDBCAdaptor adaptor, int jdbcType)` JDBCAdaptor.externalTypeForJDBCType just returns the first type it finds instead of trying to find a best match.
`protected String`	`formatValueForAttribute(EOSQLExpression expression, Object value, EOAttribute attribute, String key)`
`Number`	`getNextValFromSequenceNamed(EOEditingContext ec, String modelName, String sequenceName)` Convenience method to get the next unique ID from a sequence.
`boolean`	`handleDatabaseException(EODatabaseContext databaseContext, Throwable throwable)` Returns true if the SQL helper can handle the exception.
`int`	`jdbcTypeForCustomType(int jdbcType)` Returns the JDBC type to use for a given ERXSQLHelper custom type
`String`	`limitExpressionForSQL(EOSQLExpression expression, EOFetchSpecification fetchSpecification, String sql, long start, long end)`
`protected int`	`maximumElementPerInClause(EOEntity entity)` The database specific limit, or or most efficient number, of elements in an IN clause in a statement.
`String`	`migrationTableName()` Returns the name of the table to use for database migrations.
`static ERXSQLHelper`	`newSQLHelper(EOAdaptor adaptor)`
`static ERXSQLHelper`	`newSQLHelper(EOAdaptorChannel adaptorChannel)`
`static ERXSQLHelper`	`newSQLHelper(EODatabaseChannel databaseChannel)`
`static ERXSQLHelper`	`newSQLHelper(EODatabaseContext databaseContext)`
`static ERXSQLHelper`	`newSQLHelper(EOEditingContext ec, EOEntity entity)`
`static ERXSQLHelper`	`newSQLHelper(EOEditingContext ec, EOModel model)`
`static ERXSQLHelper`	`newSQLHelper(EOEditingContext ec, String modelName)`
`static ERXSQLHelper`	`newSQLHelper(EOEntity entity)`
`static ERXSQLHelper`	`newSQLHelper(EOModel model)`
`static ERXSQLHelper`	`newSQLHelper(EOSQLExpression expression)`
`static ERXSQLHelper`	`newSQLHelper(JDBCAdaptor adaptor)`
`static ERXSQLHelper`	`newSQLHelper(JDBCPlugIn plugin)`
`static ERXSQLHelper`	`newSQLHelper(String databaseProductName)`
`void`	`prepareConnectionForSchemaChange(EOEditingContext ec, EOModel model)`
`String`	`quoteColumnName(String columnName)`
`String`	`readFormatForAggregateFunction(String functionName, String columnName, String aggregateName)` Returns the attribute read format for an aggregate function for a particular column with a name.
`String`	`readFormatForAggregateFunction(String functionName, String columnName, String aggregateName, boolean usesDistinct)` Returns the attribute read format for an aggregate function for a particular column with a name.
`boolean`	`reassignExternalTypeForValueTypeOverride(EOAttribute attribute)`
`void`	`removeSelectFromExpression(EOAttribute attribute, EOSQLExpression sqlExpression)` Removes an attribute from the select list.
`void`	`restoreConnectionSettingsAfterSchemaChange(EOEditingContext ec, EOModel model)`
`int`	`rowCountForFetchSpecification(EOEditingContext ec, EOFetchSpecification spec)` Returns the number of rows the supplied EOFetchSpecification would return.
`boolean`	`shouldExecute(String sql)`
`boolean`	`shouldPerformDistinctInMemory(EOFetchSpecification fetchSpecification)` Returns whether or not this database should perform the distinct portion of the given fetch spec in memory or not.
`NSArray<String>`	`splitSQLStatements(String sql)` Splits semicolon-separate sql statements into an array of strings
`NSArray<String>`	`splitSQLStatementsFromFile(File f)` Splits the SQL statements from the given file.
`NSArray<String>`	`splitSQLStatementsFromInputStream(InputStream is)` Splits the SQL statements from the given input stream
`EOSQLExpression`	`sqlExpressionForFetchSpecification(EOEditingContext ec, EOFetchSpecification spec, long start, long end)` Creates the SQL which is used by the provided EOFetchSpecification, limited by the given range.
`EOSQLExpression`	`sqlExpressionForFetchSpecification(EOEditingContext ec, EOFetchSpecification spec, long start, long end, NSArray<EOAttribute> attributes)` Creates the SQL which is used by the provided EOFetchSpecification, limited by the given range.
`protected String`	`sqlForCountDistinct(EOEntity entity)` Returns the SQL to count the distinct number of rows.
`String`	`sqlForCreateIndex(String indexName, String tableName, ERXSQLHelper.ColumnIndex... columnIndexes)` Returns the SQL expression for creating an index on the given set of columns
`String`	`sqlForCreateIndex(String indexName, String tableName, String... columnNames)` Returns the SQL expression for creating an index on the given set of columns
`String`	`sqlForCreateUniqueIndex(String indexName, String tableName, ERXSQLHelper.ColumnIndex... columnIndexes)` Returns the SQL expression for creating a unique index on the given set of columns
`String`	`sqlForCreateUniqueIndex(String indexName, String tableName, String... columnNames)` Returns the SQL expression for creating a unique index on the given set of columns
`String`	`sqlForFullTextQuery(ERXFullTextQualifier qualifier, EOSQLExpression expression)` Returns the SQL expression for a full text search query.
`protected String`	`sqlForGetNextValFromSequencedNamed(String sequenceName)` Returns the SQL required to select the next value from the given sequence.
`String`	`sqlForRegularExpressionQuery(String key, String value)` Returns the SQL expression for a regular expression query.
`protected String`	`sqlForSubquery(String subquery, String alias)` Returns the syntax for using the given query as an aliased subquery in a from-clause.
`String`	`sqlWhereClauseStringForKey(EOSQLExpression e, String key, NSArray valueArray)` Creates a where clause string " someKey IN ( someValue1,...)".
`int`	`varcharLargeColumnWidth()` Returns the width that should be used for a varcharLarge column in migrations.
`int`	`varcharLargeJDBCType()` Returns the JDBCType that should be used for a varcharLarge column in migrations.

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

- Constructor Detail
  - ERXSQLHelper
```
public ERXSQLHelper()
```
- Method Detail
  - prepareConnectionForSchemaChange
```
public void prepareConnectionForSchemaChange(EOEditingContext ec,
                                             EOModel model)
```
  - restoreConnectionSettingsAfterSchemaChange
```
public void restoreConnectionSettingsAfterSchemaChange(EOEditingContext ec,
                                                       EOModel model)
```
  - shouldExecute
```
public boolean shouldExecute(String sql)
```
  - createSchemaSQLForEntitiesInModelWithNameAndOptions
```
public String createSchemaSQLForEntitiesInModelWithNameAndOptions(NSArray<EOEntity> entities,
                                                                  String modelName,
                                                                  NSDictionary optionsCreate)
```
    creates SQL to create tables for the specified Entities. This can be used with EOUtilities rawRowsForSQL method to create the tables.
    
    Parameters:
    
    entities - a NSArray containing the entities for which create table statements should be generated or null if all entities in the model should be used.
    
    modelName - the name of the EOModel
    
    optionsCreate -
    
    Returns:
    
    a String containing SQL statements to create tables
  - createSchemaSQLForEntitiesInModelAndOptions
```
public String createSchemaSQLForEntitiesInModelAndOptions(NSArray<EOEntity> entities,
                                                          EOModel model,
                                                          NSDictionary optionsCreate)
```
    creates SQL to create tables for the specified Entities. This can be used with EOUtilities rawRowsForSQL method to create the tables.
    
    Parameters:
    
    entities - a NSArray containing the entities for which create table statements should be generated or null if all entities in the model should be used.
    
    model - the EOModel
    
    optionsCreate - a NSDictionary containing the different options
    
    Returns:
    
    a String containing SQL statements to create tables
  - createSchemaSQLForEntitiesWithOptions
```
public String createSchemaSQLForEntitiesWithOptions(NSArray<EOEntity> entities,
                                                    EODatabaseContext databaseContext,
                                                    NSDictionary<String,String> optionsCreate)
```
    Creates the schema sql for a set of entities.
    
    Parameters:
    
    entities - the entities to create sql for
    
    databaseContext - the database context to use
    
    optionsCreate - the options (@see createSchemaSQLForEntitiesInModelWithNameAndOptions)
    
    Returns:
    
    a sql script
  - createDependentSchemaSQLForEntities
```
public String createDependentSchemaSQLForEntities(NSArray<EOEntity> entities,
                                                  EOAdaptor adaptor)
```
    Generates table create statements for a set of entities, then finds all the entities that those entities depend on (in other models) and generates foreign key statements for those, so you can generate sql for cross-model.
    
    Parameters:
    
    entities - the entities to generate for
    
    adaptor - the adaptor to use
    
    Returns:
    
    the sql script
  - createSchemaSQLForEntitiesWithOptions
```
public String createSchemaSQLForEntitiesWithOptions(NSArray<EOEntity> entities,
                                                    EOAdaptor adaptor,
                                                    NSDictionary<String,String> optionsDictionary)
```
    Creates the schema sql for a set of entities.
    
    Parameters:
    
    entities - the entities to create sql for
    
    adaptor - the adaptor to use
    
    optionsDictionary - the options (@see createSchemaSQLForEntitiesInModelWithNameAndOptions)
    
    Returns:
    
    a sql script
  - createSchemaSQLForEntitiesInModelWithName
```
public String createSchemaSQLForEntitiesInModelWithName(NSArray<EOEntity> entities,
                                                        String modelName)
```
    creates SQL to create tables for the specified Entities. This can be used with EOUtilities rawRowsForSQL method to create the tables.
    
    Parameters:
    
    entities - a NSArray containing the entities for which create table statements should be generated or null if all entities in the model should be used.
    
    modelName - the name of the EOModel
    
    Returns:
    
    a String containing SQL statements to create tables
  - createSchemaSQLForEntitiesInModel
```
public String createSchemaSQLForEntitiesInModel(NSArray<EOEntity> entities,
                                                EOModel model)
```
    Creates SQL to create tables for the specified Entities. This can be used with EOUtilities rawRowsForSQL method to create the tables.
    
    Parameters:
    
    entities - a NSArray containing the entities for which create table statements should be generated or null if all entities in the model should be used.
    
    model - the EOModel
    
    Returns:
    
    a String containing SQL statements to create tables
  - defaultOptionDictionary
```
public NSMutableDictionary<String,String> defaultOptionDictionary(boolean create,
                                                                  boolean drop)
```
    Creates an option dictionary to use with the other methods
    Parameters:
    
    create - add create statements
    drop - add drop statements
    This method uses the following defaults options:
    
    EOSchemaGeneration.DropTablesKey=YES if drop
    
    EOSchemaGeneration.DropPrimaryKeySupportKey=YES if drop
    
    EOSchemaGeneration.CreateTablesKey=YES if create
    
    EOSchemaGeneration.CreatePrimaryKeySupportKey=YES if create
    
    EOSchemaGeneration.PrimaryKeyConstraintsKey=YES if create
    
    EOSchemaGeneration.ForeignKeyConstraintsKey=YES if create
    
    EOSchemaGeneration.CreateDatabaseKey=NO
    
    EOSchemaGeneration.DropDatabaseKey=NO
    
    Possible values are YES and NO
    Returns:
    
    a String containing SQL statements to create tables
  - createSchemaSQLForEntitiesInDatabaseContext
```
public String createSchemaSQLForEntitiesInDatabaseContext(NSArray<EOEntity> entities,
                                                          EODatabaseContext databaseContext,
                                                          boolean create,
                                                          boolean drop)
```
    creates SQL to create tables for the specified Entities. This can be used with EOUtilities rawRowsForSQL method to create the tables.
    
    Parameters:
    
    entities - a NSArray containing the entities for which create table statements should be generated or null if all entities in the model should be used.
    
    databaseContext - the databaseContext
    
    create - if true, tables and keys are created
    
    drop - if true, tables and keys are dropped
    
    Returns:
    
    a String containing SQL statements to create tables
  - createIndexSQLForEntities
```
public String createIndexSQLForEntities(NSArray<EOEntity> entities)
```
  - createIndexSQLForEntities
```
public String createIndexSQLForEntities(NSArray<EOEntity> entities,
                                        NSArray<String> externalTypesToIgnore)
```
  - attributesToFetchForEntity
```
public NSArray<EOAttribute> attributesToFetchForEntity(EOFetchSpecification fetchSpec,
                                                       EOEntity entity)
```
    Returns the list of attributes to fetch for a fetch spec. The entity is passed in here because it has likely already been looked up for the particular fetch spec.
    
    Parameters:
    
    fetchSpec - the fetch spec
    
    entity - the entity (which should match fetchSpec.entityName())
    
    Returns:
    
    the list of attributes to fetch
  - sqlExpressionForFetchSpecification
```
public EOSQLExpression sqlExpressionForFetchSpecification(EOEditingContext ec,
                                                          EOFetchSpecification spec,
                                                          long start,
                                                          long end)
```
    Creates the SQL which is used by the provided EOFetchSpecification, limited by the given range.
    
    Parameters:
    
    ec - the EOEditingContext
    
    spec - the EOFetchSpecification in question
    
    start - start of rows to fetch
    
    end - end of rows to fetch (-1 if not used)
    
    Returns:
    
    the EOSQLExpression which the EOFetchSpecification would use
  - customQueryExpressionHintAsString
```
public String customQueryExpressionHintAsString(Object hint)
```
    Returns the custom query expression hint as a String. At the moment, if it's an EOSQLExpression, it just returns .statement().
    
    Parameters:
    
    hint - the hint to convert to a String
    
    Returns:
    
    the hint as a String
  - sqlExpressionForFetchSpecification
```
public EOSQLExpression sqlExpressionForFetchSpecification(EOEditingContext ec,
                                                          EOFetchSpecification spec,
                                                          long start,
                                                          long end,
                                                          NSArray<EOAttribute> attributes)
```
    Creates the SQL which is used by the provided EOFetchSpecification, limited by the given range.
    
    Parameters:
    
    ec - the EOEditingContext
    
    spec - the EOFetchSpecification in question
    
    start - start of rows to fetch
    
    end - end of rows to fetch (-1 if not used)
    
    attributes - the attributes to fetch from the given entity
    
    Returns:
    
    the EOSQLExpression which the EOFetchSpecification would use
  - limitExpressionForSQL
```
public String limitExpressionForSQL(EOSQLExpression expression,
                                    EOFetchSpecification fetchSpecification,
                                    String sql,
                                    long start,
                                    long end)
```
  - removeSelectFromExpression
```
public void removeSelectFromExpression(EOAttribute attribute,
                                       EOSQLExpression sqlExpression)
```
    Removes an attribute from the select list.
    
    Parameters:
    
    attribute - the attribute to remove from the select list
    
    sqlExpression - the expression to remove from
  - readFormatForAggregateFunction
```
public String readFormatForAggregateFunction(String functionName,
                                             String columnName,
                                             String aggregateName)
```
    Returns the attribute read format for an aggregate function for a particular column with a name.
    
    Parameters:
    
    functionName - the aggregate function to generate
    
    columnName - the column name to aggregate on
    
    aggregateName - the name to assign to the aggregate result
    
    Returns:
    
    the generated read format
  - readFormatForAggregateFunction
```
public String readFormatForAggregateFunction(String functionName,
                                             String columnName,
                                             String aggregateName,
                                             boolean usesDistinct)
```
    Returns the attribute read format for an aggregate function for a particular column with a name.
    
    Parameters:
    
    functionName - the aggregate function to generate
    
    columnName - the column name to aggregate on
    
    aggregateName - the name to assign to the aggregate result
    
    usesDistinct - true if function should be used on distinct values
    
    Returns:
    
    the generated read format
  - appendItemToListString
```
public void appendItemToListString(String itemString,
                                   StringBuffer listString)
```
    Adds itemString to a comma-separated list. If listString already has entries, this method appends a comma followed by itemString. There is no good way to hook in and use EOSQLExpression's version of this, so we have our own copy of it.
    
    Parameters:
    
    itemString - the item to append
    
    listString - the list buffer
  - addGroupByClauseToExpression
```
public void addGroupByClauseToExpression(EOEditingContext editingContext,
                                         EOFetchSpecification fetchSpec,
                                         EOSQLExpression expression)
```
    Adds a group-by clause to the given SQL Expression based on the list of attributes defined in the given fetch spec.
    
    Parameters:
    
    editingContext - the editing context to lookup entities with
    
    fetchSpec - the fetch spec to retrieve attributes from
    
    expression - the sql expression to add a "group by" clause to
  - _orderByIndex
```
public int _orderByIndex(EOSQLExpression expression)
```
    Returns the index in the expression's statement where order by clauses should be inserted.
    
    Parameters:
    
    expression - the expression to look into
    
    Returns:
    
    the index into statement where the order by should be inserted
  - _groupByOrHavingIndex
```
public int _groupByOrHavingIndex(EOSQLExpression expression)
```
    Returns the index in the expression's statement where group by and having clauses should be inserted.
    
    Parameters:
    
    expression - the expression to look into
    
    Returns:
    
    the index into statement where the group by should be inserted
  - addGroupByClauseToExpression
```
public void addGroupByClauseToExpression(NSArray<EOAttribute> attributes,
                                         EOSQLExpression expression)
```
    Adds a group-by clause to the given SQL Expression based on the given list of attributes.
    
    Parameters:
    
    attributes - the list of attributes to group by
    
    expression - the sql expression to add a "group by" clause to
  - addHavingCountClauseToExpression
```
public void addHavingCountClauseToExpression(NSSelector selector,
                                             int value,
                                             EOSQLExpression expression)
```
    Adds a " having count(*) > x" clause to a group by expression.
    
    Parameters:
    
    selector - the comparison selector -- just like EOKeyValueQualifier
    
    value - the value to compare against
    
    expression - the expression to modify
  - sqlForRegularExpressionQuery
```
public String sqlForRegularExpressionQuery(String key,
                                           String value)
```
    Returns the SQL expression for a regular expression query.
    
    Parameters:
    
    key -
    
    value -
    
    Returns:
    
    the regex SQL
  - sqlForFullTextQuery
```
public String sqlForFullTextQuery(ERXFullTextQualifier qualifier,
                                  EOSQLExpression expression)
```
    Returns the SQL expression for a full text search query.
    
    Parameters:
    
    qualifier - the full text qualifier
    
    expression - the EOSQLExpression context
    
    Returns:
    
    a SQL expression
  - sqlForCreateUniqueIndex
```
public String sqlForCreateUniqueIndex(String indexName,
                                      String tableName,
                                      String... columnNames)
```
    Returns the SQL expression for creating a unique index on the given set of columns
    
    Parameters:
    
    indexName - the name of the index to create
    
    tableName - the name of the containing table
    
    columnNames - the list of column names to index on
    
    Returns:
    
    a SQL expression
  - sqlForCreateUniqueIndex
```
public String sqlForCreateUniqueIndex(String indexName,
                                      String tableName,
                                      ERXSQLHelper.ColumnIndex... columnIndexes)
```
    Returns the SQL expression for creating a unique index on the given set of columns
    
    Parameters:
    
    indexName - the name of the index to create
    
    tableName - the name of the containing table
    
    columnIndexes - the list of columns to index on
    
    Returns:
    
    a SQL expression
  - sqlForCreateIndex
```
public String sqlForCreateIndex(String indexName,
                                String tableName,
                                String... columnNames)
```
    Returns the SQL expression for creating an index on the given set of columns
    
    Parameters:
    
    indexName - the name of the index to create
    
    tableName - the name of the containing table
    
    columnNames - the list of column names to index on
    
    Returns:
    
    a SQL expression
  - columnIndexesFromColumnNames
```
protected ERXSQLHelper.ColumnIndex[] columnIndexesFromColumnNames(String... columnNames)
```
  - sqlForCreateIndex
```
public String sqlForCreateIndex(String indexName,
                                String tableName,
                                ERXSQLHelper.ColumnIndex... columnIndexes)
```
    Returns the SQL expression for creating an index on the given set of columns
    
    Parameters:
    
    indexName - the name of the index to create
    
    tableName - the name of the containing table
    
    columnIndexes - the list of columns to index on
    
    Returns:
    
    a SQL expression
  - varcharLargeJDBCType
```
public int varcharLargeJDBCType()
```
    Returns the JDBCType that should be used for a varcharLarge column in migrations.
    
    Returns:
    
    the JDBCType that should be used for a varcharLarge column in migrations
  - varcharLargeColumnWidth
```
public int varcharLargeColumnWidth()
```
    Returns the width that should be used for a varcharLarge column in migrations.
    
    Returns:
    
    the width that should be used for a varcharLarge column in migrations
  - migrationTableName
```
public String migrationTableName()
```
    Returns the name of the table to use for database migrations.
    
    Returns:
    
    the name of the table to use for database migrations
  - jdbcTypeForCustomType
```
public int jdbcTypeForCustomType(int jdbcType)
```
    Returns the JDBC type to use for a given ERXSQLHelper custom type
    
    Parameters:
    
    jdbcType - the ERXSQLHelper custom type
    
    Returns:
    
    the JDBC type to use
  - externalTypeForJDBCType
```
public String externalTypeForJDBCType(JDBCAdaptor adaptor,
                                      int jdbcType)
```
    JDBCAdaptor.externalTypeForJDBCType just returns the first type it finds instead of trying to find a best match. This can still fail, mind you, but it should be much better than the EOF default impl.
    
    Parameters:
    
    adaptor - the adaptor to retrieve an external type for
    
    jdbcType - the JDBC type number
    
    Returns:
    
    a guess at the external type name to use
  - rowCountForFetchSpecification
```
public int rowCountForFetchSpecification(EOEditingContext ec,
                                         EOFetchSpecification spec)
```
    Returns the number of rows the supplied EOFetchSpecification would return.
    
    Parameters:
    
    ec - the EOEditingContext
    
    spec - the EOFetchSpecification in question
    
    Returns:
    
    the number of rows
  - sqlForCountDistinct
```
protected String sqlForCountDistinct(EOEntity entity)
```
    Returns the SQL to count the distinct number of rows. The general implementation doesn't support composite primary keys and chooses only one primary key column when formatting the SQL expression.
    Concrete classes may override this implementation to add support for composite primary keys according to their database specific SQL syntax.
    
    Parameters:
    
    entity - the base entity used in this query
    
    Returns:
    
    the formatted SQL count using distinct for the given entity
  - sqlForSubquery
```
protected String sqlForSubquery(String subquery,
                                String alias)
```
    Returns the syntax for using the given query as an aliased subquery in a from-clause.
    
    Parameters:
    
    subquery - the subquery to wrap
    
    alias - the alias to use
    
    Returns:
    
    the formatted subquery expression
  - sqlForGetNextValFromSequencedNamed
```
protected String sqlForGetNextValFromSequencedNamed(String sequenceName)
```
    Returns the SQL required to select the next value from the given sequence. This should return a single row with a single column.
    
    Parameters:
    
    sequenceName - the name of the sequence
    
    Returns:
    
    the next sequence value
  - getNextValFromSequenceNamed
```
public Number getNextValFromSequenceNamed(EOEditingContext ec,
                                          String modelName,
                                          String sequenceName)
```
    Convenience method to get the next unique ID from a sequence.
    
    Parameters:
    
    ec - editing context
    
    modelName - name of the model which connects to the database that has the sequence in it
    
    sequenceName - name of the sequence
    
    Returns:
    
    next value in the sequence
  - sqlWhereClauseStringForKey
```
public String sqlWhereClauseStringForKey(EOSQLExpression e,
                                         String key,
                                         NSArray valueArray)
```
    Creates a where clause string " someKey IN ( someValue1,...)". Can migrate keyPaths.
    
    Parameters:
    
    e - the SQL expression
    
    key - the name of the key
    
    valueArray - an array of values to generate an "in" clause for
    
    Returns:
    
    the where clause for the given key
  - maximumElementPerInClause
```
protected int maximumElementPerInClause(EOEntity entity)
```
    The database specific limit, or or most efficient number, of elements in an IN clause in a statement. If there are more that this number of elements, additional IN clauses will be generated, ORed to the others.
    
    Parameters:
    
    entity - EOEntity that can be used to fine-tune the result
    
    Returns:
    
    database specific limit, or or most efficient number, of elements in an IN clause in a statement
  - formatValueForAttribute
```
protected String formatValueForAttribute(EOSQLExpression expression,
                                         Object value,
                                         EOAttribute attribute,
                                         String key)
```
  - splitSQLStatements
```
public NSArray<String> splitSQLStatements(String sql)
```
    Splits semicolon-separate sql statements into an array of strings
    
    Parameters:
    
    sql - a multi-line sql statement
    
    Returns:
    
    an array of sql statements
  - splitSQLStatementsFromInputStream
```
public NSArray<String> splitSQLStatementsFromInputStream(InputStream is)
                                                  throws IOException
```
    Splits the SQL statements from the given input stream
    
    Parameters:
    
    is - the input stream to read from
    
    Returns:
    
    an array of SQL statements
    
    Throws:
    
    IOException - if there is a problem reading the stream
  - splitSQLStatementsFromFile
```
public NSArray<String> splitSQLStatementsFromFile(File f)
                                           throws IOException
```
    Splits the SQL statements from the given file.
    
    Parameters:
    
    f - the file to read from
    
    Returns:
    
    an array of SQL statements
    
    Throws:
    
    IOException - if there is a problem reading the stream
  - commandSeparatorChar
```
protected char commandSeparatorChar()
```
    This is totally cheating ... But I just need the separator character for now. We can rewrite the script parser later. Actually, somewhere on earth there is already a sql parser or two. Probably worth getting that one.
    
    Returns:
    
    the separator character used by this database
  - commandSeparatorString
```
protected String commandSeparatorString()
```
  - commentPattern
```
protected Pattern commentPattern()
```
    Returns a pattern than matches only blank lines. Subclasses should implement this to return a pattern matching the vendor specific comment indicator(s).
    
    Returns:
    
    regex pattern that indicates this line is an SQL comment
  - columnNamesFromColumnIndexes
```
public NSMutableArray<String> columnNamesFromColumnIndexes(ERXSQLHelper.ColumnIndex... columnIndexes)
```
  - reassignExternalTypeForValueTypeOverride
```
public boolean reassignExternalTypeForValueTypeOverride(EOAttribute attribute)
```
  - quoteColumnName
```
public String quoteColumnName(String columnName)
```
  - canReliablyPerformDistinctWithSortOrderings
```
protected boolean canReliablyPerformDistinctWithSortOrderings()
```
    Returns whether or not this database can always perform the a distinct operation when sort orderings are applied. Oracle, for instance, will fail if you try to sort on a key that isn't in the list of fetched keys.
    
    Returns:
    
    whether or not this database can always perform the a distinct operation when sort orderings are applied
  - shouldPerformDistinctInMemory
```
public boolean shouldPerformDistinctInMemory(EOFetchSpecification fetchSpecification)
```
    Returns whether or not this database should perform the distinct portion of the given fetch spec in memory or not.
    
    Parameters:
    
    fetchSpecification - the fetch spec to check
    
    Returns:
    
    whether or not this database should perform the distinct portion of the given fetch spec in memory or not
  - handleDatabaseException
```
public boolean handleDatabaseException(EODatabaseContext databaseContext,
                                       Throwable throwable)
```
    Returns true if the SQL helper can handle the exception. Typical uses are morphing unique constraints to NSValidation exceptions.
    
    Parameters:
    
    databaseContext -
    
    throwable -
    
    Returns:
    
    whether or not the SQL helper can handl this exception
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EOSQLExpression expression)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EOEditingContext ec,
                                        String modelName)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EOEditingContext ec,
                                        EOEntity entity)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EOEditingContext ec,
                                        EOModel model)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EODatabaseContext databaseContext)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EODatabaseChannel databaseChannel)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EOAdaptor adaptor)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EOAdaptorChannel adaptorChannel)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(JDBCAdaptor adaptor)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(JDBCPlugIn plugin)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EOEntity entity)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(EOModel model)
```
  - newSQLHelper
```
public static ERXSQLHelper newSQLHelper(String databaseProductName)
```

Class ERXSQLHelper

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ERXSQLHelper

Method Detail

prepareConnectionForSchemaChange

restoreConnectionSettingsAfterSchemaChange

shouldExecute

createSchemaSQLForEntitiesInModelWithNameAndOptions

createSchemaSQLForEntitiesInModelAndOptions

createSchemaSQLForEntitiesWithOptions

createDependentSchemaSQLForEntities

createSchemaSQLForEntitiesWithOptions

createSchemaSQLForEntitiesInModelWithName

createSchemaSQLForEntitiesInModel

defaultOptionDictionary

createSchemaSQLForEntitiesInDatabaseContext

createIndexSQLForEntities

createIndexSQLForEntities

attributesToFetchForEntity

sqlExpressionForFetchSpecification

customQueryExpressionHintAsString

sqlExpressionForFetchSpecification

limitExpressionForSQL

removeSelectFromExpression

readFormatForAggregateFunction

readFormatForAggregateFunction

appendItemToListString

addGroupByClauseToExpression

_orderByIndex

_groupByOrHavingIndex

addGroupByClauseToExpression

addHavingCountClauseToExpression

sqlForRegularExpressionQuery

sqlForFullTextQuery

sqlForCreateUniqueIndex

sqlForCreateUniqueIndex

sqlForCreateIndex

columnIndexesFromColumnNames

sqlForCreateIndex

varcharLargeJDBCType

varcharLargeColumnWidth

migrationTableName

jdbcTypeForCustomType

externalTypeForJDBCType

rowCountForFetchSpecification

sqlForCountDistinct

sqlForSubquery

sqlForGetNextValFromSequencedNamed

getNextValFromSequenceNamed

sqlWhereClauseStringForKey

maximumElementPerInClause

formatValueForAttribute

splitSQLStatements

splitSQLStatementsFromInputStream

splitSQLStatementsFromFile

commandSeparatorChar

commandSeparatorString

commentPattern

columnNamesFromColumnIndexes

reassignExternalTypeForValueTypeOverride

quoteColumnName

canReliablyPerformDistinctWithSortOrderings

shouldPerformDistinctInMemory

handleDatabaseException

newSQLHelper

newSQLHelper

newSQLHelper

newSQLHelper

newSQLHelper

newSQLHelper

newSQLHelper

newSQLHelper

newSQLHelper

newSQLHelper

newSQLHelper

newSQLHelper