PATH Documentation > WebObjects 4.5 > EOAccess Reference

EOSQLExpression

Inherits from: NSObject

Conforms to: NSObject
(NSObject)

Declared in: EOAccess/EOSQLExpression.h
EOAccess/EOSchemaGeneration.h
EOAccess/EOSchemaSynchronization.h

Class Description

EOSQLExpression is an abstract superclass that defines how to build SQL statements for adaptor channels. You don't typically use instances of EOSQLExpression; rather, you use EOSQLExpression subclasses written to work with a particular RDBMS and corresponding adaptor. A concrete subclass of EOSQLExpression overrides many of its methods in terms of the query language syntax for its specific RDBMS. EOSQLExpression objects are used internally by the Framework, and unless you're creating a concrete adaptor, you won't ordinarily need to interact with EOSQLExpression objects yourself. You most commonly create and use an EOSQLExpression object when you want to send an SQL statement directly to the server. In this case, you simply create an expression with the EOSQLExpression class method expressionForString:, and send the expression object to an adaptor channel using EOAdaptorChannel's evaluateExpression: method.

For more information on using EOSQLExpressions, see the following sections:

Constants

In EOSQLExpression.h, EOSchemaGeneration.h, and EOSchemaSynchronization.h, EOAccess defines the following NSString constants.

Constant	Description
`EOBindVariableNameKey`	The key for the name of a bind variable in a bind variable dictionary.
`EOBindVariablePlaceHolderKey`	A key for use in bind variable dictionaries. The corresponding value is the placeholder string to be used in SQL.
`EOBindVariableAttributeKey`	A key for use in bind variable dictionaries. The corresponding value is the attribute that uses the bind variable.
`EOBindVariableValueKey`	A key for use in bind variable dictionaries. The corresponding value is the value for the bind variable.
`EOCreateTablesKey`	Key for use in options dictionaries. A corresponding value of "YES" indicates that the EOSQLExpression should generate SQL to create tables.
`EODropTablesKey`	Key for use in options dictionaries. A corresponding value of "YES" indicates that the EOSQLExpression should generate SQL to drop tables.
`EOCreatePrimaryKeySupportKey`	Key for use in options dictionaries. A corresponding value of "YES" indicates that the EOSQLExpression should generate SQL to create primary key support.
`EODropPrimaryKeySupportKey`	Key for use in options dictionaries. A corresponding value of "YES" indicates that the EOSQLExpression should generate SQL to drop primary key support.
`EOPrimaryKeyConstraintsKey`	Key for use in options dictionaries. A corresponding value of "YES" indicates that the EOSQLExpression should generate SQL to create primary key constraints.
`EOForeignKeyConstraintsKey`	Key for use in options dictionaries. A corresponding value of "YES" indicates that the EOSQLExpression should generate SQL to create foreign key constraints.
`EOCreateDatabaseKey`	Key for use in options dictionaries. A corresponding value of "YES" indicates that the EOSQLExpression should generate SQL to create a database.
`EODropDatabaseKey`	Key for use in options dictionaries. A corresponding value of "YES" indicates that the EOSQLExpression should generate SQL to drop a database.
`EOAllowsNullKey`	Key for use in change dictionaries. A corresponding value indicates that the column's allows NULL value should be changed from.
`EOColumnNameKey`	Key for use in change dictionaries. A corresponding value indicates that the column's allows NULL value should be changed from.
`EOExternalNameKey`	Key for use in change dictionaries. A corresponding value indicates that the column's allows NULL value should be changed from.
`EOExternalTypeKey`	Key for use in change dictionaries. A corresponding value indicates that the column's allows NULL value should be changed from.
`EONameKey`	Key for use in change dictionaries. A corresponding value indicates the old value of the table or column.
`EOPrecisionKey`	Key for use in change dictionaries. A corresponding value indicates the value a column's precision should be changed from.
`EORelationshipsKey`	Key for use in change dictionaries. The corresponding value is a dictionary of relationships which have been modified since the last time the model and schema were sychronized. For more information see "The Change Dictionary" .
`EOScaleKey`	Key for use in change dictionaries. A corresponding value indicates the value the column's scale should be changed from.
`EOWidthKey`	Key for use in change dictionaries. A corresponding value indicates the value the column's width should be changed from.

Method Types

Creating an EOSQLExpression object

+ selectStatementForAttributes:lock:fetchSpecification:entity:

+ insertStatementForRow:entity:

+ updateStatementForRow:qualifier:entity:

+ deleteStatementWithQualifier:entity:

+ expressionForString:

- initWithEntity:

Building SQL Expressions

- prepareSelectExpressionWithAttributes:lock:fetchSpecification:

- prepareInsertExpressionWithRow:

- prepareUpdateExpressionWithRow:qualifier:

- prepareDeleteExpressionForQualifier:

- setStatement:

- statement

Generating SQL for attributes and values

+ formatSQLString:format:

+ formatValue:forAttribute:

+ formatStringValue:

- sqlStringForValue:attributeNamed:

- sqlStringForAttributeNamed:

- sqlStringForAttribute:

- sqlStringForAttributePath:

Generating SQL for names of database objects

- sqlStringForSchemaObjectName:

+ setUseQuotedExternalNames:

+ useQuotedExternalNames

- externalNameQuoteCharacter

Generating an attribute list

- addSelectListAttribute:

- addInsertListAttribute:value:

- addUpdateListAttribute:value:

- appendItem:toListString:

- listString

Generating a value list

- addInsertListAttribute:value:

- addUpdateListAttribute:value:

- valueList

Generating a table list

- tableListWithRootEntity:

- aliasesByRelationshipPath

Generating the join clause

- joinExpression

- addJoinClauseWithLeftName:rightName:joinSemantic:

- assembleJoinClauseWithLeftName:rightName:joinSemantic:

- joinClauseString

Generating a search pattern

+ sqlPatternFromShellPattern:

+ sqlPatternFromShellPattern:withEscapeCharacter:

Generating a relational operator

- sqlStringForSelector:value:

Accessing the where clause

- whereClauseString

Generating an order by clause

- addOrderByAttributeOrdering:

- orderByString

Accessing the lock clause

- lockClause

Assembling a statement

- assembleSelectStatementWithAttributes:lock:qualifier:fetchOrder:selectString:columnList:tableList:whereClause:joinClause:orderByClause:lockClause:

- assembleInsertStatementWithRow:tableList:columnList:valueList:

- assembleUpdateStatementWithRow:qualifier:tableList:updateList:whereClause:

- assembleDeleteStatementWithQualifier:tableList:whereClause:

Generating SQL for qualifiers

- sqlStringForConjoinedQualifiers:

- sqlStringForDisjoinedQualifiers:

- sqlStringForKeyComparisonQualifier:

- sqlStringForKeyValueQualifier:

- sqlStringForNegatedQualifier:

Managing bind variables

+ setUseBindVariables:

+ useBindVariables

- addBindVariableDictionary:

- bindVariableDictionaries

- bindVariableDictionaryForAttribute:value:

- mustUseBindVariableForAttribute:

- shouldUseBindVariableForAttribute:

Using table aliases

- setUseAliases:

- useAliases

Accessing the entity

- entity

Creating a schema generation script

+ schemaCreationScriptForEntities:options:

+ schemaCreationStatementsForEntities:options:

+ appendExpression:toScript:

+ createTableStatementsForEntityGroup:

+ createTableStatementsForEntityGroups:

+ dropTableStatementsForEntityGroup:

+ dropTableStatementsForEntityGroups:

+ primaryKeyConstraintStatementsForEntityGroup:

+ primaryKeyConstraintStatementsForEntityGroups:

+ primaryKeySupportStatementsForEntityGroup:

+ primaryKeySupportStatementsForEntityGroups:

+ dropPrimaryKeySupportStatementsForEntityGroup:

+ dropPrimaryKeySupportStatementsForEntityGroups:

- addCreateClauseForAttribute:

- columnTypeStringForAttribute:

- allowsNullClauseForConstraint:

+ foreignKeyConstraintStatementsForRelationship:

- prepareConstraintStatementForRelationship:sourceColumns:destinationColumns:

- createDatabaseStatementsForConnectionDictionary:administrativeConnectionDictionary:

- dropDatabaseStatementsForConnectionDictionary:administrativeConnectionDictionary:

Synchronizing the database with a model

+ statementsToUpdateObjectStoreForModel:withChangeDictionary:options:

+ statementsToUpdateObjectStoreForEntityGroup:withChangeDictionary:options:

+ statementsToCopyTableNamed:intoTableForEntityGroup:withChangeDictionary:options:

+ phraseCastingColumnNamed:fromType:toType:options:

+ statementsToRenameTableNamed:newName:options:

+ statementsToInsertColumnForAttribute:options:

+ statementsToDeleteColumnNamed:inTableNamed:options:

+ statementsToRenameColumnNamed:inTableNamed:newName:options:

+ statementsToModifyColumnNamed:inTableNamed:toNullRule:

+ statementsToConvertColumnNamed:inTableNamed:fromType:toType:options:

+ isColumnType:equivalentToColumnType:options:

+ statementsToDropForeignKeyConstraintsOnEntityGroup:withChangeDictionary:options:

+ statementsToDropPrimaryKeyConstraintsOnEntityGroup:withChangeDictionary:options:

+ statementsToDropPrimaryKeySupportForEntityGroup:withChangeDictionary:options:

+ statementsToImplementForeignKeyConstraintsOnEntityGroup:withChangeDictionary:options:

+ statementsToImplementPrimaryKeyConstraintsOnEntityGroup:withChangeDictionary:options:

+ statementsToImplementPrimaryKeySupportForEntityGroup:withChangeDictionary:options:

Querying about database synchronization support

+ supportsSchemaSynchronization

+ supportsDirectColumnCoercion

+ supportsDirectColumnDeletion

+ supportsDirectColumnInsertion

+ supportsDirectColumnNullRuleModification

+ supportsDirectColumnRenaming

Class Methods

appendExpression:toScript:

+ (void)appendExpression:(EOSQLExpression *)anSQLExpression toScript:(NSMutableString *)script

Append's anSQLExpression's statement to script along with any necessary delimiter. EOSQLExpression's implementation appends the SQL statement for anSQLExpression to script followed by a semicolon and a newline. A subclass of EOSQLExpression only needs to override this method if the delimiter for its database server is different. For example, the Oracle and Informix use the default implementation, whereas the Sybase adaptor appends the word "go" instead of a semicolon.

createDatabaseStatementsForConnectionDictionary:administrativeConnectionDictionary:

+ (NSArray *)createDatabaseStatementsForConnectionDictionary:(NSDictionary *)connectionDictionary administrativeConnectionDictionary:(NSDictionary *)adminDictionary

Generates the SQL statements that will create a database (or user, for Oracle) that can be accessed by the provided connection dictionary and administrative connection dictionary.

createTableStatementsForEntityGroup:

+ (NSArray *)createTableStatementsForEntityGroup:(NSArray *)entityGroup

Returns an array of EOSQLExpression objects that define the SQL necessary to create a table for entityGroup, an array of EOEntity objects that have the same externalName. Returns an empty array if entityGroup is nil or empty.

EOSQLExpression's implementation does the following:

Creates an EOSQLExpression object.
Sets the expression's entity to the first entity in entityGroup.
Adds a create clause for each Attribute in entityGroup's Entities.
Sets the expression's statement to CREATE TABLE TABLE_NAME (LIST_STRING), where TABLE_NAME is the externalName of the Entity objects in entityGroup and LIST_STRING is the expression's listString.
Adds the expression to an array.
Returns the array.

The following is an example of a CREATE TABLE statement produced by the default implementation:

create table EMPLOYEE (
    EMP_ID      int not null,
    DEPT_ID     int null,
    LAST_NAME   varchar(40) not null,
    PHONE       char(12) null,
    HIRE_DATE   date null,
    SALARY      number(7, 2) null
)

If a subclass's database server's table creation semantics are different, the subclass should override this method or one or more of the following methods as appropriate:

addCreateClauseForAttribute:
columnTypeStringForAttribute:
allowsNullClauseForConstraint:

createTableStatementsForEntityGroups:

+ (NSArray *)createTableStatementsForEntityGroups:(NSArray *)entityGroups

Returns an array of EOSQLExpression objects that define the SQL necessary to create the tables specified in entityGroups. An entity group is an array of Entity objects that have the same externalName, and entityGroups is an array of entity groups. Returns an empty array if entityGroups is nil or empty. EOSQLExpression's implementation invokes createTableStatementsForEntityGroup: for each entity group in entityGroups and returns an array of all the resulting EOSQLExpressions.

deleteStatementWithQualifier:entity:

+ (EOSQLExpression *)deleteStatementWithQualifier:(EOQualifier *)qualifier entity:(id)entity

Creates and returns an SQL DELETE expression to delete the rows described by qualifier. Creates an instance of EOSQLExpression, initializes it with entity (an EOEntity object), and sends it a prepareDeleteExpressionForQualifier: message. Raises an NSInvalidArgumentException if qualifier is nil.

The expression created with this method does not use table aliases because Enterprise Objects Framework assumes that all INSERT, UPDATE, and DELETE statements are single-table operations. As a result, all keys in qualifier should be simple key names; no key paths are allowed. To generate DELETE statements that do use table aliases, you must override prepareDeleteExpressionForQualifier: to send a setUseAliases:YES message prior to invoking super's version.

dropDatabaseStatementsForConnectionDictionary:administrativeConnectionDictionary:

+ (NSArray *)dropDatabaseStatementsForConnectionDictionary:(NSDictionary *)connectionDictionary administrativeConnectionDictionary:(NSDictionary *)adminDictionary

Generates the SQL statements to drop a database (or user, for Oracle).

dropPrimaryKeySupportStatementsForEntityGroup:

+ (NSArray *)dropPrimaryKeySupportStatementsForEntityGroup:(NSArray *)entityGroup

Returns an array of EOSQLExpression objects that define the SQL necessary to drop the primary key generation support for entityGroup, an array of Entity objects that have the same externalName. The drop statement generated by this method should be sufficient to remove the primary key support created by primaryKeySupportStatementsForEntityGroup:'s statements.

EOSQLExpression's implementation creates a statement of the following form:

drop sequence SEQUENCE_NAME

Where SEQUENCE_NAME is the primaryKeyRootName: for the first entity in entityGroup concatenated with "_SEQ" (EMP_ID_SEQ, for example).

If a subclass uses a different primary key generation mechanism or if the subclass's database server's drop semantics are different, the subclass should override this method.

dropPrimaryKeySupportStatementsForEntityGroups:

+ (NSArray *)dropPrimaryKeySupportStatementsForEntityGroups:(NSArray *)entityGroups

Returns an array of EOSQLExpression objects that define the SQL necessary to drop the primary key generation support for the entities specified in entityGroups. An entity group is an array of EOEntity objects that have the same externalName, and entityGroups is an array of entity groups. EOSQLExpression's implementation invokes dropPrimaryKeySupportStatementsForEntityGroup: for each entity group in entityGroups and returns an array of all the resulting EOSQLExpressions.

dropTableStatementsForEntityGroup:

+ (NSArray *)dropTableStatementsForEntityGroup:(NSArray *)entityGroup

Returns an array of EOSQLExpression objects that define the SQL necessary to drop the table identified by entityGroup, an array of Entity objects that have the same externalName. The drop statement generated by this method should be sufficient to remove the table created by createTableStatementsForEntityGroup:'s statements.

EOSQLExpression's implementation creates a statement of the following form:

DROP TABLE TABLE_NAME

Where TABLE_NAME is the externalName of the first entity in entityGroup.

If a subclass's database server's drop semantics are different, the subclass should override this method.

dropTableStatementsForEntityGroups:

+ (NSArray *)dropTableStatementsForEntityGroups:(NSArray *)entityGroups

Returns an array of EOSQLExpression objects that define the SQL necessary to drop the tables for entityGroups. An entity group is an array of Entity objects that have the same externalName, and entityGroups is an array of entity groups. EOSQLExpression's implementation invokes dropTableStatementsForEntityGroup: for each entity group in entityGroups and returns an array of all the resulting EOSQLExpressions.

expressionForString:

+ (EOSQLExpression *)expressionForString:(NSString *)string

Creates and returns an SQL expression for string. string should be a valid expression in the target query language. This method does not perform substitutions or formatting of any kind.

See Also: - setStatement:

foreignKeyConstraintStatementsForRelationship:

+ (NSArray *)foreignKeyConstraintStatementsForRelationship:(EORelationship *)aRelationship

Returns an array of EOSQLExpression objects that define the SQL necessary to create foreign key constraints for aRelationship. EOSQLExpression's implementation generates statements such as the following:

ALTER TABLE EMPLOYEE ADD CONSTRAINT TO_DEPARTMENT FOREIGN KEY (DEPT_ID)
        REFERENCES DEPARTMENT(DEPT_ID)

It returns an empty array if either of the following are true:

aRelationship spans models (if aRelationship's destinationEntity is in a different model than aRelationship's source entity)
aRelationship is a to-many relationship, or if the inverse relationship of aRelationship is not a to-many. In other words, foreign key constraint statements are only created for to-one relationships whose inverse is a to-many.

If neither of the above are true, this method creates a new EOSQLExpression, assigns its entity to aRelationship's entity, invokes prepareConstraintStatementForRelationship:sourceColumns:destinationColumns:, and returns an array containing the expression.

If a subclass's database server's foreign key constraint semantics are different, the subclass should override this method or override the method prepareConstraintStatementForRelationship:sourceColumns:destinationColumns:.

formatSQLString:format:

+ (NSString *)formatSQLString:(NSString *)sqlString format:(NSString *)format

Applies format (an EOAttribute object's "read" or "write" format) to sqlString (a value for the attribute). If format is nil, this method returns sqlString unchanged.

See Also: - readFormat (EOAttribute), - writeFormat (EOAttribute)

formatStringValue:

+ (NSString *)formatStringValue:(NSString *)string

Formats string for use as a string constant in a SQL statement. EOSQLExpression's implementation encloses the string in single quotes, escaping any single quotes already present in string. Raises an NSInternalInconsistencyException if string is nil.

formatValue:forAttribute:

+ (NSString *)formatValue:(id)value forAttribute:(EOAttribute *)attribute

Overridden by subclasses to return a string representation of value suitable for use in an SQL statement. EOSQLExpression's implementation returns value unchanged. A subclass should override this method to format value depending on attribute's externalType. For example, a subclass might format a date using a special database-specific syntax or standard form or truncate numbers to attribute's precision and scale.

insertStatementForRow:entity:

+ (EOSQLExpression *)insertStatementForRow:(NSDictionary *)row entity:(EOEntity *)entity

Creates and returns an SQL INSERT expression to insert row. Creates an instance of EOSQLExpression, initializes it with entity, and sends it prepareInsertExpressionWithRow:. Raises an NSInvalidArgumentException if entity is nil.

The expression created with this method does not use table aliases because Enterprise Objects Framework assumes that all INSERT, UPDATE, and DELETE statements are single-table operations. To generate INSERT statements that do use table aliases, you must override prepareInsertExpressionWithRow: to send a setUseAliases:YES message prior to invoking super's version.

isColumnType:equivalentToColumnType:options:

+ (BOOL)isColumnType:(id <EOColumnTypes>)columnTypeA equivalentToColumnType:(id <EOColumnTypes>)columnTypeB options:(NSDictionary *)options

Returns YES if values in a column of columnTypeA can be copied into a column of columnTypeB without the use of a casting phrase, NO otherwise. The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

phraseCastingColumnNamed:fromType:toType:options:

+ (NSString *)phraseCastingColumnNamed:(NSString *)columnName fromType:(id <EOColumnTypes>)type toType:(id <EOColumnTypes>)castType options:(NSDictionary *)options

Returns an SQL string to cast the values in the column specified by columnName to a new type. This method is used when the adaptor doesn't support in-place column type coercion, and the table has to be recreated. To move data from the old table to the new table, sometimes a conversion statement is needed (for example, to convert strings in a VARCHAR column to numbers). The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

primaryKeyConstraintStatementsForEntityGroup:

+ (NSArray *)primaryKeyConstraintStatementsForEntityGroup:(NSArray *)entityGroup

Returns an array of EOSQLExpression objects that define the SQL necessary to create the primary key constraints for entityGroup, an array of EOEntity objects that have the same externalName. Returns an empty array if any of the primary key attributes in entityGroup don't have a columnName.

EOSQLExpression's implementation creates a statement of the following form:

ALTER TABLE TABLE_NAME ADD PRIMARY KEY (PRIMARY_KEY_COLUMN_NAMES)

Where TABLE_NAME is the externalName for the first entity in entityGroup and PRIMARY_KEY_COLUMN_NAMES is a comma-separated list of the columnNames of the first entity's primaryKeyAttributes.

If the subclass's database server's primary key constraint semantics are different, the subclass should override this method.

primaryKeyConstraintStatementsForEntityGroups:

+ (NSArray *)primaryKeyConstraintStatementsForEntityGroups:(NSArray *)entityGroups

Returns an array of EOSQLExpression objects that define the SQL necessary to create the primary key constraints for the Entities specified in entityGroups. An entity group is an array of Entity objects that have the same externalName, and entityGroups is an array of entity groups. EOSQLExpression's implementation invokes primaryKeySupportStatementsForEntityGroup: for each entity group in entityGroups and returns an array of all the resulting EOSQLExpressions.

primaryKeySupportStatementsForEntityGroup:

+ (NSArray *)primaryKeySupportStatementsForEntityGroup:(NSArray *)entityGroup

Returns an array of EOSQLExpression objects that define the SQL necessary to create the primary key generation support for entityGroup, an array of EOEntity objects that have the same externalName. EOSQLExpression's implementation creates a statement of the following form:

create sequence SEQUENCE_NAME

Where SEQUENCE_NAME is the primaryKeyRootName: for the first entity in entityGroup concatenated with "_SEQ" (EMP_ID_SEQ, for example).

If a subclass uses a different primary key generation mechanism or if the subclass's database server's drop semantics are different, the subclass should override this method.

See Also: + dropPrimaryKeySupportStatementsForEntityGroup:, - primaryKeyForNewRowWithEntity: (EOAdaptorChannel)

primaryKeySupportStatementsForEntityGroups:

+ (NSArray *)primaryKeySupportStatementsForEntityGroups:(NSArray *)entityGroups

Returns an array of EOSQLExpression objects that define the SQL necessary to create the primary key generation support for the Entities specified in entityGroups. An entity group is an array of Entity objects that have the same externalName, and entityGroups is an array of entity groups. EOSQLExpression's implementation invokes primaryKeySupportStatementsForEntityGroup: for each entity group in entityGroups and returns an array of all the resulting EOSQLExpressions.

schemaCreationScriptForEntities:options:

+ (NSArray *)schemaCreationScriptForEntities:(NSArray *)entities options:(NSDictionary *)options

Returns a script of SQL statements suitable to create the schema for the EOEntity objects in entities. The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" . EOSQLExpression's implementation invokes schemaCreationStatementsForEntities:options: with entities and options and then uses appendExpression:toScript: to generate the script from the EOSQLExpressions generated by schemaCreationStatementsForEntities:options:.

schemaCreationStatementsForEntities:options:

+ (NSArray *)schemaCreationStatementsForEntities:(NSArray *)entities options:(NSDictionary *)options

Returns an array of EOSQLExpressions suitable to create the schema for the Entity objects in entities. The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

EOSQLExpression's implementation uses the following methods:

createTableStatementsForEntityGroups:
dropTableStatementsForEntityGroups:
primaryKeySupportStatementsForEntityGroups:
dropPrimaryKeySupportStatementsForEntityGroups:
primaryKeyConstraintStatementsForEntityGroups:
foreignKeyConstraintStatementsForRelationship:

to generate EOSQLExpressions for the support identified in options.

selectStatementForAttributes:lock:fetchSpecification:entity:

+ (EOSQLExpression *)selectStatementForAttributes:(NSArray *)attributes lock:(BOOL)flag fetchSpecification:(EOFetchSpecification *)fetchSpecification entity:(EOEntity *)entity

Creates and returns an SQL SELECT expression. Creates an instance of EOSQLExpression, initializes it with entity, and sends it prepareSelectExpressionWithAttributes:lock:fetchSpecification:. The expression created with this method uses table aliases. Raises an NSInvalidArgumentException if attributes is nil or empty, fetchSpecification is nil, or entity is nil.

The expression created with this method uses table aliases. To generate SELECT statements that don't use them, you must override prepareSelectExpressionWithAttributes:lock:fetchSpecification: to send a setUseAliases:NO message prior to invoking super's version.

setUseBindVariables:

+ (void)setUseBindVariables:(BOOL)flag

Sets according to flag whether all instances of EOSQLExpression subclasses use bind variables. By default, instances don't use bind variables; if the value for the global user default named EOAdaptorUseBindVariables is YES, though, instances do use them. For more information on bind variables, see the discussion in the class description.

See Also: + useBindVariables

setUseQuotedExternalNames:

+ (void)setUseQuotedExternalNames:(BOOL)flag

Sets whether all instances of EOSQLExpression subclasses quote external names when they are referenced in SQL statements. By setting flag to YES, you can access database tables with names such as "%return", "1st year", and "TABLE" that you couldn't otherwise access. By default, instances don't quote external names; if the value for the global user default named EOAdaptorQuotesExternalNames is YES, though, instances do use quotes.

sqlPatternFromShellPattern:

+ (NSString *)sqlPatternFromShellPattern:(NSString *)pattern

Translates a "like" qualifier to an SQL "like" expression. Invoked from sqlStringForKeyValueQualifier: when the qualifier argument is an EOKeyValueQualifier object whose selector is EOQualifierOperatorLike. EOSQLExpression's implementation performs the following substitutions

Character in pattern	Substitution string
*	%
?	_
%	[%] (unless the percent character appears in square brackets)
_	[_] (unless the underscore character appears in square brackets)

sqlPatternFromShellPattern:withEscapeCharacter:

+ (NSString *)sqlPatternFromShellPattern:(NSString *)pattern withEscapeCharacter:(unichar)escapeCharacter

Like sqlPatternFromShellPattern: except the argument escapeCharacter allows you to specify a character for escaping the wild card characters "%" and "_".

statementsToConvertColumnNamed:inTableNamed:fromType:toType:options:

+ (NSArray *)statementsToConvertColumnNamed:(NSString *)columnName inTableNamed:(NSString *)tableName fromType:(id <EOColumnTypes>)type toType:(id <EOColumnTypes>)newType options:(NSDictionary *)options

Returns an array of EOSQLExpressions to convert in place the type of the specified column. The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToCopyTableNamed:intoTableForEntityGroup:withChangeDictionary:options:

+ (NSArray *)statementsToCopyTableNamed:(NSString *)tableName intoTableForEntityGroup:(NSArray *)entityGroup withChangeDictionary:(NSDictionary *)changes options:(NSDictionary *)options

Returns an array of EOSQLExpressions to copy the specified table into a new table, whose definition is provided by entityGroup-an array of EOEntity objects rooted to the table named tableName. This method is used when the adaptor doesn't support the in-place table modifications required to synchronize the database to a model.

The changes dictionary identifies the changes to make to the database schema; for more information, see "The Change Dictionary" . The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToDeleteColumnNamed:inTableNamed:options:

+ (NSArray *)statementsToDeleteColumnNamed:(NSString *)columnName inTableNamed:(NSString *)tableName options:(NSDictionary *)options

Returns an array of EOSQLExpressions to delete in place the specified column from the specified table. The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToDropForeignKeyConstraintsOnEntityGroup:withChangeDictionary:options:

+ (NSArray *)statementsToDropForeignKeyConstraintsOnEntityGroup:(NSArray *)entityGroup withChangeDictionary:(NSDictionary *)changes options:(NSDictionary *)options

Returns an array of EOSQLExpressions to drop foreign key constraints for the table corresponding to entityGroup-an array of EOEntity objects rooted to the same table. The changes dictionary identifies the changes to make to the database schema; for more information, see "The Change Dictionary" . The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToDropPrimaryKeyConstraintsOnEntityGroup:withChangeDictionary:options:

+ (NSArray *)statementsToDropPrimaryKeyConstraintsOnEntityGroup:(NSArray *)entityGroup withChangeDictionary:(NSDictionary *)changes options:(NSDictionary *)options

Returns an array of EOSQLExpressions to drop primary key constraints for the table corresponding to entityGroup-an array of EOEntity objects rooted to the same table. The changes dictionary identifies the changes to make to the database schema; for more information, see "The Change Dictionary" . The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToDropPrimaryKeySupportForEntityGroup:withChangeDictionary:options:

+ (NSArray *)statementsToDropPrimaryKeySupportForEntityGroup:(NSArray *)entityGroup withChangeDictionary:(NSDictionary *)changes options:(NSDictionary *)options

Returns an array of EOSQLExpressions to drop the primary key support mechanism for the table corresponding to entityGroup-an array of EOEntity objects rooted to the same table. The changes dictionary identifies the changes to make to the database schema; for more information, see "The Change Dictionary" . The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToImplementForeignKeyConstraintsOnEntityGroup:withChangeDictionary:options:

+ (NSArray *)statementsToImplementForeignKeyConstraintsOnEntityGroup:(NSArray *)entityGroup withChangeDictionary:(NSDictionary *)changes options:(NSDictionary *)options

Returns an array of EOSQLExpressions to implement foreign key constraints on the table corresponding to entityGroup-an array of EOEntity objects rooted to the same table. The changes dictionary identifies the changes to make to the database schema; for more information, see "The Change Dictionary" . The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToImplementPrimaryKeyConstraintsOnEntityGroup:withChangeDictionary:options:

+ (NSArray *)statementsToImplementPrimaryKeyConstraintsOnEntityGroup:(NSArray *)entityGroup withChangeDictionary:(NSDictionary *)changes options:(NSDictionary *)options

Returns an array of EOSQLExpressions to implement primary key constraints on the table corresponding to entityGroup-an array of EOEntity objects rooted to the same table. The changes dictionary identifies the changes to make to the database schema; for more information, see "The Change Dictionary" . The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToImplementPrimaryKeySupportForEntityGroup:withChangeDictionary:options:

+ (NSArray *)statementsToImplementPrimaryKeySupportForEntityGroup:(NSArray *)entityGroup withChangeDictionary:(NSDictionary *)changes options:(NSDictionary *)options

Returns an array of EOSQLExpressions to implement support mechanisms for primary key generation for the table corresponding to entityGroup-an array of EOEntity objects rooted to the same table. The changes dictionary identifies the changes to make to the database schema; for more information, see "The Change Dictionary" . The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToInsertColumnForAttribute:options:

+ (NSArray *)statementsToInsertColumnForAttribute:(EOAttribute *)attribute options:(NSDictionary *)options

Returns an array of EOSQLExpressions to insert in place a column for the specified attribute. The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToModifyColumnNamed:inTableNamed:toNullRule:

+ (NSArray *)statementsToModifyColumnNamed:(NSString *)columnName inTableNamed:(NSString *)tableName toNullRule:(BOOL)allowsNull options:(NSDictionary *)options

Returns an array of EOSQLExpressions to modify in place the specified column to either allow or not allow NULL values as specified by allowsNull. The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToRenameColumnNamed:inTableNamed:newName:options:

+ (NSArray *)statementsToRenameColumnNamed:(NSString *)columnName inTableNamed:(NSString *)tableName newName:(NSString *)newName options:(NSDictionary *)options

Returns an array of EOSQLExpressions to rename in place the specified column. The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToRenameTableNamed:newName:options:

+ (NSArray *)statementsToRenameTableNamed:(NSString *)tableName newName:(NSString *)newName options:(NSDictionary *)options

Returns an array of EOSQLExpressions to rename in place the specified table. The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToUpdateObjectStoreForEntityGroup:withChangeDictionary:options:

+ (NSArray *)statementsToUpdateStoreForEntityGroup:(NSArray *)entityGroup withChangeDictionary:(NSDictionary *)changes options:(NSDictionary *)options

Returns an array of EOSQLExpressions to update the table that corresponds to entityGroup-an array of EOEntity objects rooted to the same table. Inserts and deletes columns, and updates modified columns. The changes dictionary identifies the changes to make to the database schema; for more information, see "The Change Dictionary" . The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

statementsToUpdateObjectStoreForModel:withChangeDictionary:options:

+ (NSArray *)statementsToUpdateObjectStoreForModel:(EOModel *)model withChangeDictionary:(NSDictionary *)changes options:(NSDictionary *)options

Returns an array of EOSQLExpressions to synchronize the database with model. Prepares the statements to insert and delete new and deleted tables before invoking statementsToUpdateObjectStoreForEntityGroup:withChangeDictionary:options: for each modified table. The changes dictionary identifies the changes to make to the database schema; for more information, see "The Change Dictionary" . The options dictionary describes the aspects of the schema for which to create SQL statements; for more information, see "The Options Dictionary" .

supportsDirectColumnCoercion

+ (BOOL)supportsDirectColumnCoercion

Returns YES if the adaptor can change the type of an existing column in place, NO otherwise.

supportsDirectColumnDeletion

+ (BOOL)supportsDirectColumnDeletion

Returns YES if the adaptor can delete columns, NO otherwise.

supportsDirectColumnInsertion

+ (BOOL)supportsDirectColumnInsertion

Returns YES if the adaptor can add columns to a table, NO otherwise.

supportsDirectColumnNullRuleModification

+ (BOOL)supportsDirectColumnNullRuleModification

Returns YES if the adaptor can modify the null rule of an existing column in place, NO otherwise.

supportsDirectColumnRenaming

+ (BOOL)supportsDirectColumnRenaming

Returns YES if the adaptor can rename table columns, NO otherwise.

supportsSchemaSynchronization

+ (BOOL)supportsSchemaSynchronization

Returns YES if the adaptor can update the database to reflect changes in a model, NO otherwise.

updateStatementForRow:qualifier:entity:

+ (EOSQLExpression *)updateStatementForRow:(NSDictionary *)row qualifier:(EOQualifier *)qualifier entity:(EOEntity *)entity

Creates and returns an SQL UPDATE expression to update the row identified by qualifier with the values in row. row should only contain entries for values that have actually changed. Creates an instance of EOSQLExpression, initializes it with entity, and sends it prepareUpdateExpressionWithRow:qualifier:.

Raises an NSInvalidArgumentException if row is nil or empty, qualifier is nil, or entity is nil.

The expression created with this method does not use table aliases because Enterprise Objects Framework assumes that all INSERT, UPDATE, and DELETE statements are single-table operations. As a result, all keys in qualifier should be simple key names; no key paths are allowed. To generate UPDATE statements that do use table aliases, you must override prepareUpdateExpressionWithRow:qualifier: to send a setUseAliases:YES message prior to invoking super's version.

See Also: - setUseAliases:

useBindVariables

+ (BOOL)useBindVariables

Returns YES if instances use bind variables, NO otherwise. For more information on bind variables, see the discussion in the class description.

See Also: + setUseBindVariables:

useQuotedExternalNames

+ (BOOL)useQuotedExternalNames

Returns YES if instances use quoted external names, NO otherwise.

Instance Methods

addBindVariableDictionary:

- (void)addBindVariableDictionary:(NSMutableDictionary *)binding

Adds binding to the receiver's array of bind variable dictionaries. binding is generally created using the method bindVariableDictionaryForAttribute:value: and is added to the receiver's bind variable dictionaries in sqlStringForValue:attributeNamed: when the receiver uses a bind variable for the specified attribute. See the method description for bindVariableDictionaryForAttribute:value: for a description of the contents of a bind variable dictionary, and for more information on bind variables, see the discussion in the class description.

See Also: - bindVariableDictionaries

addCreateClauseForAttribute:

- (void)addCreateClauseForAttribute:(EOAttribute *)attribute

Adds the SQL string for creating attribute to a comma-separated list of attribute creation clauses. The list is constructed for use in a CREATE TABLE statement produced by createTableStatementsForEntityGroup:. Use the method listString to access creation clauses.

EOSQLExpression's implementation creates clauses in the following form:

COLUMN_NAME COLUMN_TYPE ALLOWS_NULL_CLAUSE

Where

COLUMN_TYPE is the string returned from columnTypeStringForAttribute: for anAttribute.
ALLOWS_NULL_CLAUSE is the string returned from allowsNullClauseForConstraint: with YES if anAttribute allowsNull or with NO if anAttribute doesn't.

addInsertListAttribute:value:

- (void)addInsertListAttribute:(EOAttribute *)attribute value:(NSString *)value

Adds the SQL string for attribute to a comma-separated list of attributes and value to a comma-separated list of values. Both lists are constructed for use in an INSERT statement. Use the methods listString and valueList to access the attributes and value lists.

Invokes appendItem:toListString: to add an SQL string for attribute to the receiver's listString, and again to add a formatted SQL string for value to the receiver's valueList.

addJoinClauseWithLeftName:rightName:joinSemantic:

- (void)addJoinClauseWithLeftName:(NSString *)leftName rightName:(NSString *)rightName joinSemantic:(EOJoinSemantic)semantic

Creates a new join clause by invoking assembleJoinClauseWithLeftName:rightName:joinSemantic: and adds it to the receiver's join clause string. Separates join conditions already in the join clause string with the word "and". Invoked from joinExpression.

See Also: - joinClauseString

addOrderByAttributeOrdering:

- (void)addOrderByAttributeOrdering:(EOSortOrdering *)sortOrdering

Adds an attribute-direction pair ("LAST_NAME asc", for example) to the receiver's ORDER BY string. If sortOrdering's selector is EOCompareCaseInsensitiveAscending or EOCompareCaseInsensitiveAscending, the string generated has the format "upper(attribute) direction". Use the method orderByString to access the ORDER BY string. addOrderByAttributeOrdering: invokes appendItem:toListString: to add the attribute-direction pair.

See Also: - sqlStringForAttributeNamed:

addSelectListAttribute:

- (void)addSelectListAttribute:(EOAttribute *)attribute

Adds an SQL string for attribute to a comma-separated list of attribute names for use in a SELECT statement. The SQL string for attribute is formatted with attribute's "read" format. Use listString to access the list. addSelectListAttribute: invokes appendItem:toListString: to add the attribute name.

See Also: - sqlStringForAttribute:, + formatSQLString:format:, - readFormat (EOAttribute)

addUpdateListAttribute:value:

- (void)addUpdateListAttribute:(EOAttribute *)attribute value:(NSString *)value

Adds an attribute-value assignment ("LAST_NAME = ‘Thomas'", for example) to a comma-separated list for use in an UPDATE statement. Formats value with attribute's "write" format. Use listString to access the list. addUpdateListAttribute:value: invokes appendItem:toListString: to add the attribute-value assignment.

See Also: + formatSQLString:format:

aliasesByRelationshipPath

- (NSMutableDictionary *)aliasesByRelationshipPath

Returns a dictionary of table aliases. The keys of the dictionary are relationship paths-"department" and "department.location", for example. The values are the table aliases for the corresponding table-"t1" and "t2", for example. The aliasesByRelationshipPath dictionary always has at least one entry: an entry for the EOSQLExpression's entity. The key of this entry is the empty string (@"") and the value is "t0". The dictionary returned from this method is built up over time with successive calls to sqlStringForAttributePath:.

See Also: - tableListWithRootEntity:

allowsNullClauseForConstraint:

- (NSString *)allowsNullClauseForConstraint:(BOOL)flag

Returns according to flag an adaptor specific string for use in a CREATE TABLE statement. The returned string indicates whether a column allows null values. EOSQLExpression's implementation returns the empty string if flag is YES, "NOT NULL" otherwise. A subclass should override this if its database server's semantics are different. For example, the SybaseSLQExpression returns "null" if flag is YES, the empty string otherwise.

See Also: + addCreateClauseForAttribute:

appendItem:toListString:

- (void)appendItem:(NSString *)itemString toListString:(NSMutableString *)listString

Adds itemString to a comma-separated list. If listString already has entries, this method appends a comma followed by itemString. Invoked from addSelectListAttribute:, addInsertListAttribute:value:, addUpdateListAttribute:value:, and addOrderByAttributeOrdering:

assembleDeleteStatementWithQualifier:tableList:whereClause:

- (NSString *)assembleDeleteStatementWithQualifier:(EOQualifier *)qualifier tableList:(NSString *)tableList whereClause:(NSString *)whereClause

Invoked from prepareDeleteExpressionForQualifier: to return an SQL DELETE statement of the form:

DELETE FROM tableList
SQL_WHERE whereClause

qualifier is the argument to prepareDeleteExpressionForQualifier: from which whereClause was derived. It is provided for subclasses that need to generate the WHERE clause in a particular way.

assembleInsertStatementWithRow:tableList:columnList:valueList:

- (NSString *)assembleInsertStatementWithRow:(NSDictionary *)row tableList:(NSString *)tableList columnList:(NSString *)columnList valueList:(NSString *)valueList

Invoked from prepareInsertExpressionWithRow: to return an SQL INSERT statement of the form:

INSERT INTO tableList (columnList)
VALUES valueList

or, if columnList is nil:

INSERT INTO tableList
VALUES valueList

row is the argument to prepareInsertExpressionWithRow: from which columnList and valueList were derived. It is provided for subclasses that need to generate the list of columns and values in a particular way.

assembleJoinClauseWithLeftName:rightName:joinSemantic:

- (NSString *)assembleJoinClauseWithLeftName:(NSString *)leftName rightName:(NSString *)rightName joinSemantic:(EOJoinSemantic)semantic

Returns a join clause of the form:

leftName operator rightName

Where operator is "=" for an inner join, "*=" for a left-outer join, and "=*" for a right-outer join. Invoked from addJoinClauseWithLeftName:rightName:joinSemantic:.

assembleSelectStatementWithAttributes:lock:qualifier:fetchOrder:selectString:columnList:tableList:whereClause:joinClause:orderByClause:lockClause:

- (NSString *)assembleSelectStatementWithAttributes:(NSArray *)attributes lock:(BOOL)lock qualifier:(EOQualifier *)qualifier fetchOrder:(NSArray *)fetchOrder selectString:(NSString *)selectString columnList:(NSString *)columnList tableList:(NSString *)tableList whereClause:(NSString *)whereClause joinClause:(NSString *)joinClause orderByClause:(NSString *)orderByClause lockClause:(NSString *)lockClause

Invoked from prepareSelectExpressionWithAttributes:lock:fetchSpecification: to return an SQL SELECT statement of the form:

SELECT columnList
FROM tableList lockClause 
WHERE whereClause AND joinClause 
ORDER BY orderByClause

If lockClause is nil, it is omitted from the statement. Similarly, if orderByClause is nil, the "ORDER BY orderByClause" is omitted. If either whereClause or joinClause is nil, the "AND" and nil-valued argument are omitted. If both are nil, the entire WHERE clause is omitted.

attributes, lock, qualifier, and fetchOrder are the arguments to prepareSelectExpressionWithAttributes:lock:fetchSpecification: from which the other assembleSelect... arguments were derived. They are provided for subclasses that need to generate the clauses of the SELECT statement in a particular way.

assembleUpdateStatementWithRow:qualifier:tableList:updateList:whereClause:

- (NSString *)assembleUpdateStatementWithRow:(NSDictionary *)row qualifier:(EOQualifier *)qualifier tableList:(NSString *)tableList updateList:(NSString *)updateList whereClause:(NSString *)whereClause

Invoked from prepareUpdateExpressionWithRow:qualifier: to return an SQL UPDATE statement of the form:

UPDATE tableList
SET updateList
WHERE whereClause

row and qualifier are the arguments to prepareUpdateExpressionWithRow:qualifier: from which updateList and whereClause were derived. They are provided for subclasses that need to generate the clauses of the UPDATE statement in a particular way.

bindVariableDictionaries

- (NSArray *)bindVariableDictionaries

Returns the receiver's bind variable dictionaries. For more information on bind variables, see the discussion in the class description.

See Also: - addBindVariableDictionary:

bindVariableDictionaryForAttribute:value:

- (NSMutableDictionary *)bindVariableDictionaryForAttribute:(EOAttribute *)attribute value:(id)value

Implemented by subclasses to create and return the bind variable dictionary for attribute and value. The dictionary returned from this method must contain the following key-value pairs:

Key	Corresponding Value
`EOBindVariableNameKey`	Name of the bind variable for attribute
`EOBindVariablePlaceHolderKey`	Placeholder string used in the SQL statement
`EOBindVariableAttributeKey`	attribute
`EOBindVariableValueKey`	value

An adaptor subclass may define additional entries as required by its RDBMS.

Invoked from sqlStringForValue:attributeNamed: when the message mustUseBindVariableForAttribute:attribute returns YES or when the receiver's class uses bind variables and the message shouldUseBindVariableForAttribute:attribute returns YES. For more information on bind variables, see the discussion in the class description.

A subclass that uses bind variables should implement this method without invoking EOSQLExpression's implementation. The subclass implementation must return a dictionary with entries for the keys listed above and may add additional keys.

columnTypeStringForAttribute:

- (NSString *)columnTypeStringForAttribute:(EOAttribute *)anAttribute

Returns an adaptor specific type string for anAttribute that's suitable for use in a CREATE TABLE statement. EOSQLExpression's implementation creates a string based on anAttribute's externalType, precision, and width as follows:

If Condition	Generated String
precision is non-zero	externalType(precision, scale)
precision is zero and width is non-zero	externalType(scale)
precision and width are zero	externalType

A subclass should override the default implementation if its database server requires column types in a different format.

See Also: - addCreateClauseForAttribute:

entity

- (EOEntity *)entity

Returns the receiver's entity.

See Also: - initWithEntity:

externalNameQuoteCharacter

- (NSString *)externalNameQuoteCharacter

Returns the string ‘\"' (an escaped quote character) if the receiver uses quoted external names, or the empty string ("") otherwise.

initWithEntity:

- initWithEntity:(EOEntity *)entity

Initializes a new instance of EOSQLExpression with entity.

See Also: - entity

joinClauseString

- (NSMutableString *)joinClauseString

Returns the part of the receiver's WHERE clause that specifies join conditions. Together, the joinExpression and the whereClauseString make up a statement's WHERE clause. If the receiver's statement doesn't contain join conditions, this method returns an empty string.

An EOSQLExpression's joinClauseString is generally set by invoking joinExpression.

joinExpression

- (void)joinExpression

Builds up the joinClauseString for use in a SELECT statement. For each relationship path in the aliasesByRelationshipPath dictionary, this method invokes addJoinClauseWithLeftName:rightName:joinSemantic: for each of the relationship's EOJoin objects.

If the aliasesByRelationshipPath dictionary only has one entry (the entry for the EOSQLExpression's entity), the joinClauseString is empty.

You must invoke this method after invoking addSelectListAttribute: for each attribute to be selected and after sending sqlStringForSQLExpression:self to the qualifier for the SELECT statement. (These methods build up the aliasesByRelationshipPath dictionary by invoking sqlStringForAttributePath:.)

See Also: - whereClauseString, - sqlStringForSQLExpression: (EOQualifierSQLGeneration protocol)

listString

- (NSMutableString *)listString

Returns a comma-separated list of attributes or "attribute = value" assignments. listString is built up with successive invocations of addInsertListAttribute:value:, addSelectListAttribute:, or addUpdateListAttribute:value: for INSERT statements, SELECT statements, and UPDATE statements, respectively. The contents of listString vary according to the type of statement the receiver is building:

Type of Statement	Sample listString Contents
INSERT	FIRST_NAME, LAST_NAME, EMPLOYEE_ID
UPDATE	FIRST_NAME = "Timothy", LAST_NAME = "Richardson"
SELECT	t0.FIRST_NAME, t0.LAST_NAME, t1.DEPARTMENT_NAME

lockClause

- (NSString *)lockClause

Overridden by subclasses to return the SQL string used in a SELECT statement to lock selected rows. A concrete subclass of EOSQLExpression must override this method to return the string used by its adaptor's RDBMS.

mustUseBindVariableForAttribute:

- (BOOL)mustUseBindVariableForAttribute:(EOAttribute *)attribute

Returns YES if the receiver must use bind variables for attribute, NO otherwise. EOSQLExpression's implementation returns NO. An SQL expression subclass that uses bind variables should override this method to return YES if the underlying RDBMS requires that bind variables be used for attributes with attribute's external type.

orderByString

- (NSMutableString *)orderByString

Returns the comma-separated list of "attribute direction" pairs ("LAST_NAME asc, FIRST_NAME asc", for example) for use in a SELECT statement.

See Also: - addOrderByAttributeOrdering:

prepareConstraintStatementForRelationship:sourceColumns:destinationColumns:

- (void)prepareConstraintStatementForRelationship:(EORelationship *)relationship sourceColumns:(NSArray *)sourceColumns destinationColumns:(NSArray *)destinationColumns

Sets the receiver's statement to an adaptor specific constraint for relationship. EOSQLExpression's implementation generates statements of the form:

ALTER TABLE TABLE_NAME ADD CONSTRAINT CONSTRAINT_NAME
    FOREIGN KEY (SOURCE_KEY_LIST)
    REFERENCES DESTINATION_TABLE_NAME (DESTINATION_KEY_LIST)

Where

TABLE_NAME is the external name of the receiver's entity.
CONSTRAINT_NAME is the external name of the receiver's entity, relationship's name, and the string "FK", concatenated with underbars between them (EMPLOYEE_MANAGER_FK, for example),
SOURCE_KEY_LIST is a comma-separated list of the source columns in sourceColumns.
DESTINATION_TABLE_NAME is the external name of relationship's destination entity.
DESTINATION_KEY_LIST is a comma-separated list of the destination columns in destinationColumns

prepareDeleteExpressionForQualifier:

- (void)prepareDeleteExpressionForQualifier:(EOQualifier *)qualifier

Generates a DELETE statement by performing the following steps:

Sends an sqlStringForSQLExpression:self message to qualifier to generate the receiver's whereClauseString.
Invokes tableListWithRootEntity: to get the table name for the FROM clause.
Invokes assembleDeleteStatementWithQualifier:tableList:whereClause:.

prepareInsertExpressionWithRow:

- (void)prepareInsertExpressionWithRow:(NSDictionary *)row

Generates an INSERT statement by performing the following steps:

Invokes addInsertListAttribute:value: for each entry in row to prepare the comma-separated list of attributes and the corresponding list of values.
Invokes tableListWithRootEntity: to get the table name.
Invokes assembleInsertStatementWithRow:tableList:columnList:valueList:.

See Also: + insertStatementForRow:entity:

prepareSelectExpressionWithAttributes:lock:fetchSpecification:

- (void)prepareSelectExpressionWithAttributes:(NSArray *)attributes lock:(BOOL)flag fetchSpecification:(EOFetchSpecification *)fetchSpecification

Generates a SELECT statement by performing the following steps:

Invokes addSelectListAttribute: for each entry in attributes to prepare the comma-separated list of attributes.
Sends an sqlStringForSQLExpression:self message to fetchSpecification's qualifier to generate the receiver's whereClauseString.
Invokes addOrderByAttributeOrdering: for each EOAttributeOrdering object in fetchSpecification. First conjoins the qualifier in fetchSpecification with the restricting qualifier, if any, of the receiver's entity.
Invokes joinExpression to generate the receiver's joinClauseString.
Invokes tableListWithRootEntity: to get the comma-separated list of tables for the FROM clause.
If flag is YES, invokes lockClause to get the SQL string to lock selected rows.
Invokes assembleSelectStatementWithAttributes:lock:qualifier:fetchOrder:selectString:columnList:tableList:whereClause:joinClause:orderByClause:lockClause:.

prepareUpdateExpressionWithRow:qualifier:

- (void)prepareUpdateExpressionWithRow:(NSDictionary *)row qualifier:(EOQualifier *)qualifier

Generates an UPDATE statement by performing the following steps:

Invokes addUpdateListAttribute:value: for each entry in row to prepare the comma-separated list of "attribute = value" assignments.
Sends an sqlStringForSQLExpression:self message to qualifier to generate the receiver's whereClauseString.
Invokes tableListWithRootEntity: to get the table name for the FROM clause.
Invokes assembleUpdateStatementWithRow:qualifier:tableList:updateList:whereClause:.

setStatement:

- (void)setStatement:(NSString *)string

Sets the receiver's SQL statement to string, which should be a valid expression in the target query language. Use this method-instead of a prepare... method-to directly assign an SQL string to an EOSQLExpression object. This method does not perform substitutions or formatting of any kind.

See Also: + expressionForString:, - statement

setUseAliases:

- (void)setUseAliases:(BOOL)flag

Tells the receiver whether or not to use table aliases.

See Also: - useAliases

shouldUseBindVariableForAttribute:

- (BOOL)shouldUseBindVariableForAttribute:(EOAttribute *)attribute

Returns YES if the receiver can provide a bind variable dictionary for attribute, NO otherwise. Bind variables aren't used for values associated with this attribute when the class method useBindVariables returns NO. EOSQLExpression's implementation returns NO. An SQL expression subclass should override this method to return YES if the receiver should use bind variables for attributes with attribute's external type. It should also return YES for any attribute for which the receiver must use bind variables.

sqlStringForAttribute:

- (NSString *)sqlStringForAttribute:(EOAttribute *)attribute

Returns the SQL string for attribute, complete with a table alias if the receiver uses table aliases. Invoked from sqlStringForAttributeNamed: when the attribute name is not a path.

See Also: - sqlStringForAttributePath:

sqlStringForAttributeNamed:

- (NSString *)sqlStringForAttributeNamed:(NSString *)name

Returns the SQL string for the attribute named name, complete with a table alias if the receiver uses table aliases. Generates the return value using sqlStringForAttributePath: if name is an attribute path ("department.name", for example); otherwise, uses sqlStringForAttribute:.

sqlStringForAttributePath:

- (NSString *)sqlStringForAttributePath:(NSArray *)path

Returns the SQL string for path, complete with a table alias if the receiver uses table aliases. Invoked from sqlStringForAttributeNamed: when the specified attribute name is a path ("department.location.officeNumber", for example). path is an array of any number of EORelationship objects followed by an EOAttribute object. The EORelationship and EOAttribute objects each correspond to a component in path. For example, if the attribute name argument to sqlStringForAttributeNamed: is "department.location.officeNumber", path is an array containing the following objects in the order listed:

The EORelationship object in the receiver's entity named "department". (Assume the relationship's destination entity is named "Department".)
The EORelationship object in the Department entity named "location". (Assume the relationship's destination entity is named "Location".)
The EOAttribute object in the Location entity named "officeNumber".

Assuming that the receiver uses aliases and the alias for the Location table is t2, the SQL string for this sample attribute path is "t2.officeNumber".

If the receiver uses table aliases, this method has the side effect of adding a "relationship path"-"alias name" entry to the aliasesByRelationshipPath dictionary.

sqlStringFor:caseInsensitiveLike:

- (NSString *)sqlStringForValue:(NSString *)valueString caseInsensitiveLikeKey:(NSString *)keyString

Overridden by subclasses to return a case insensitive comparison of valueString and keyString. For example, a subclass implementation might return the string "UPPER(keyString) LIKE UPPER(valueString)".

sqlStringForConjoinedQualifiers:

- (NSString *)sqlStringForConjoinedQualifiers:(NSArray *)qualifiers

Creates and returns an SQL string that is the result of interposing the word "AND" between the SQL strings for the qualifiers in qualifiers. Generates an SQL string for each qualifier by sending sqlStringForSQLExpression: messages to the qualifiers with self as the argument. If the SQL string for a qualifier contains only white space, it isn't included in the return value. The return value is enclosed in parentheses if the SQL strings for two or more qualifiers were ANDed together.

sqlStringForDisjoinedQualifiers:

- (NSString *)sqlStringForDisjoinedQualifiers:(NSArray *)qualifiers

Creates and returns an SQL string that is the result of interposing the word "OR" between the SQL strings for the qualifiers in qualifiers. Generates an SQL string for each qualifier by sending sqlStringForSQLExpression: messages to the qualifiers with self as the argument. If the SQL string for a qualifier contains only white space, it isn't included in the return value. The return value is enclosed in parentheses if the SQL strings for two or more qualifiers were ORed together.

sqlStringForKeyComparisonQualifier:

- (NSString *)sqlStringForKeyComparisonQualifier:(EOKeyComparisonQualifier *)qualifier

Creates and returns an SQL string that is the result of interposing an operator between the SQL strings for the right and left keys in qualifier. Determines the SQL operator by invoking sqlStringForSelector:value: with qualifier's selector and nil for the value. Generates SQL strings for qualifier's keys by invoking sqlStringForAttributeNamed: to get SQL strings. This method also formats the strings for the right and left keys using formatSQLString:format: with the corresponding attributes' "read" formats.

sqlStringForKeyValueQualifier:

- (NSString *)sqlStringForKeyValueQualifier:(EOKeyValueQualifier *)qualifier

Creates and returns an SQL string that is the result of interposing an operator between the SQL strings for qualifier's key and value. Determines the SQL operator by invoking sqlStringForSelector:value: with qualifier's selector and value. Generates an SQL string for qualifier's key by invoking sqlStringForAttributeNamed: to get an SQL string and formatSQLString:format: with the corresponding attribute's "read" format. Similarly, generates an SQL string for qualifier's value by invoking sqlStringForValue:attributeNamed: to get an SQL string and formatValue:forAttribute: to format it. (First invokes sqlPatternFromShellPattern: for the value if qualifier's selector is EOQualifierOperatorLike.)

sqlStringForNegatedQualifier:

- (NSString *)sqlStringForNegatedQualifier:(EOQualifier *)qualifier

Creates and returns an SQL string that is the result of surrounding the SQL string for qualifier in parentheses and appending it to the word "not". For example, if the string for qualifier is "FIRST_NAME = ‘John'", sqlStringForNegatedQualifier: returns the string "not (FIRST_NAME = ‘John')".

Generates an SQL string for qualifier by sending an sqlStringForSQLExpression: message to qualifier with self as the argument. If the SQL string for qualifier contains only white space, this method returns nil.

sqlStringForSchemaObjectName:

- (NSString *)sqlStringForSchemaObjectName:(NSString *)name

Returns name enclosed in the external name quote character if the receiver uses quoted external names, otherwise simply returns name unaltered.

sqlStringForSelector:value:

- (NSString *)sqlStringForSelector:(SEL)selector value:(id)value

Returns an SQL operator for selector and value. The possible values for selector are defined as constants (in EOControl). The following table summarizes EOSQLExpression's default mapping:

Selector (Constant)	SQL Operator
`EOQualifierOperatorIsEqual`	"is" if value is an EONull, "=" otherwise
`EOQualifierOperatorNotEqual`	"is not" if value is an EONull, "<>" otherwise
`EOQualifierOperatorLessThan`	"<"
`EOQualifierOperatorGreaterThan`	">"
`EOQualifierOperatorLessThanOrEqualTo`	"<="
`EOQualifierOperatorGreaterThanOrEqualTo`	">="
`EOQualifierOperatorLike`	"like"

Raises an NSInternalInconsistencyException if selector is an unknown operator.

sqlStringForValue:attributeNamed:

- (NSString *)sqlStringForValue:(id)value attributeNamed:(NSString *)name

Returns a string for value appropriate for use in an SQL statement. If the receiver uses a bind variable for the attribute named name, then sqlStringForValue:attributeNamed: gets the bind variable dictionary for the attribute, adds it to the receiver's array of bind variables dictionaries, and returns the value for the binding's EOBindVariablePlaceHolderKey. Otherwise, this method invokes formatValue:forAttribute: and returns the formatted string for value.

statement

- (NSString *)statement

Returns the complete SQL statement for the receiver. An SQL statement can be assigned to an EOSQLExpression object directly using the class method expressionForString: or using the instance method setStatement:. Generally, however, an EOSQLExpression's statement is built up using one of the following methods:

- prepareSelectExpressionWithAttributes:lock:fetchSpecification:
- prepareInsertExpressionWithRow:
- prepareUpdateExpressionWithRow:qualifier:
- prepareDeleteExpressionForQualifier:

tableListWithRootEntity:

- (NSString *)tableListWithRootEntity:(EOEntity *)entity

Returns the comma-separated list of tables for use in a SELECT, UPDATE, or DELETE statement's FROM clause. If the receiver doesn't use table aliases, the table list consists only of the table name for entity-"EMPLOYEE", for example. If the receiver does use table aliases (only in SELECT statements by default), the table list is a comma separated list of table names and their aliases, for example:

EMPLOYEE t0, DEPARTMENT t1

tableListWithRootEntity: creates a string containing the table name for entity and a corresponding table alias ("EMPLOYEE t0", for example). For each entry in aliasesByRelationshipPath, this method appends a new table name and table alias.

useAliases

- (BOOL)useAliases

Returns YES if the receiver generates statements with table aliases, NO otherwise. For example, the following SELECT statement uses table aliases:

SELECT t0.FIRST_NAME, t0.LAST_NAME, t1.NAME
FROM EMPLOYEE t0, DEPARTMENT t1
WHERE t0.DEPARTMENT_ID = t1.DEPARTMENT_ID

The EMPLOYEE table has the alias t0, and the DEPARTMENT table has the alias t1.

By default, EOSQLExpression uses table aliases only in SELECT statements. Enterprise Objects Framework assumes that INSERT, UPDATE, and DELETE statements are single-table operations. For more information, see the discussion in the class description.

valueList

- (NSMutableString *)valueList

Returns the comma-separated list of values used in an INSERT statement. For example, the value list for the following INSERT statement:

INSERT EMPLOYEE (FIRST_NAME, LAST_NAME, EMPLOYEE_ID, DEPARTMENT_ID, SALARY)
VALUES ('Shaun', 'Hayes', 1319, 23, 4600)

is "‘Shaun', ‘Hayes', 1319, 23, 4600". An EOSQLExpression's valueList is generated a value at a time with addInsertListAttribute:value: messages.

whereClauseString

- (NSString *)whereClauseString

Returns the part of the receiver's WHERE clause that qualifies rows. The whereClauseString does not specify join conditions; the joinClauseString does that. Together, the whereClauseString and the joinClauseString make up a statement's where clause. For example, a qualifier for an Employee entity specifies that a statement only affects employees who belong to the Finance department and whose monthly salary is greater than $4500. Assume the corresponding where clause looks like this:

WHERE EMPLOYEE.SALARY > 4500 AND DEPARTMENT.NAME = ‘Finance'
    AND EMPLOYEE.DEPARTMENT_ID = DEPARTMENT.DEPARTMENT_ID

EOSQLExpression generates both a whereClauseString and a joinClauseString for this qualifier. The whereClauseString qualifies the rows and looks like this:

EMPLOYEE.SALARY > 4500 AND DEPARTMENT.NAME = ‘Finance'

The joinClauseString specifies the join conditions between the EMPLOYEE table and the DEPARTMENT table and looks like this:

EMPLOYEE.DEPARTMENT_ID = DEPARTMENT.DEPARTMENT_ID

An EOSQLExpression's whereClauseString is generally set by sending a sqlStringForSQLExpression: message to an EOQualifier object.

See Also: - sqlStringForSQLExpression: (EOQualifierSQLGeneration protocol)