er.extensions.jdbc
Class ERXSQLHelper

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

Direct Known Subclasses:

ERXSQLHelper.DerbySQLHelper, ERXSQLHelper.FrontBaseSQLHelper, ERXSQLHelper.MicrosoftSQLHelper, ERXSQLHelper.MySQLSQLHelper, 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

databaseProductName.SQLHelper

the class name of the SQLHelper for the database product name

Nested Class Summary

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.DerbySQLHelper
static class	ERXSQLHelper.EROracleSQLHelper
static class	ERXSQLHelper.FrontBaseSQLHelper
static class	ERXSQLHelper.MicrosoftSQLHelper
static class	ERXSQLHelper.MySQLSQLHelper
static class	ERXSQLHelper.OpenBaseSQLHelper
static class	ERXSQLHelper.OracleSQLHelper
static class	ERXSQLHelper.PostgresqlSQLHelper

Field Summary

static Logger

log logging support

Constructor Summary

ERXSQLHelper()

Method Summary

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 last of attributes to fetch for a fetch spec.
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.
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)
String	migrationTableName() Returns the name of the table to use for database migrations.
static ERXSQLHelper	newSQLHelper(EOAdaptorChannel adaptorChannel)
static ERXSQLHelper	newSQLHelper(EODatabaseChannel databaseChannel)
static ERXSQLHelper	newSQLHelper(EODatabaseContext databaseContext)
static ERXSQLHelper	newSQLHelper(EOEditingContext ec, String modelName)
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	readFormatForAggregateFunction(String functionName, String columnName, String aggregateName) 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)
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.
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.
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

Field Detail

log

public static final Logger log

logging support

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 entitites 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 entitites 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 entitites 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 entitites 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 entitites 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 last 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

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

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

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 b