Provide a Consistent Way to Clear Fields to Null/Empty Across All Field Types

Provide a consistent and supported mechanism in IBM OpenPages calculations and field operations to clear a field value and set it to null/empty across all supported field types, including Text, Enumeration, and Date fields.

Currently, the behavior for clearing fields is inconsistent across field types and can depend on whether the value is being updated immediately or after clicking Save. This makes it difficult for administrators and end users to implement reliable business rules and validations.

Current Problem

When using OpenPages calculations to clear a field, there are several limitations and inconsistencies:

1. Text fields
   • Setting a field to a single space (' ') can be used as a workaround to make the field appear empty.
   • However, a single space is not treated as a true null or empty value by downstream validation logic.
   • As a result, isEmpty(), exists, and null checks may not behave as expected.
   • This workaround can therefore introduce unintended side effects in other calculations and validation rules.
2. Enumeration fields
   • There is currently no reliable way to clear an enumeration field through a calculation.
   • Setting the value to null does not consistently clear the field.
   • Setting the value to a blank space (' ') is also not a valid solution for enumeration fields.
   • This makes it difficult to implement business logic where an enumeration value needs to be reset based on another field or status.
3. Date fields
   • Setting a date field to null does not consistently clear the value immediately.
   • In some scenarios, the field appears to clear only after the user clicks Save.
   • This creates inconsistent behavior between the calculation result and what the user sees on the screen.

Business / Usability Impact

This behavior creates several challenges for OpenPages administrators and solution developers:

• Business rules cannot reliably reset fields to an empty state.
• Developers have to implement field-specific workarounds.
• Using a space (' ') for text fields can break downstream validation and empty-value checks.
• The behavior differs between Text, Enumeration, and Date fields.
• The behavior can also differ between the immediate UI state and the saved record.
• It becomes difficult to predict whether a field has actually been cleared or still contains a value.
• Additional custom calculations and validation logic are required to work around these limitations.

Proposed Enhancement

Provide a standard and consistent mechanism to set a field to null/empty through OpenPages calculations and related field operations.

The enhancement should:

1. Support clearing Text fields by setting them to a true null/empty value.
2. Support clearing Enumeration fields and returning them to an unselected/empty state.
3. Support clearing Date fields immediately by setting them to null.
4. Ensure that a cleared field is consistently recognized by:
   • isEmpty()
   • exists
   • null checks
   • Other validation and calculation functions
5. Ensure that the clearing behavior is consistent before and after Save.
6. Avoid requiring workarounds such as setting a text field to a single space (' ').

Expected Behavior

For example, if a calculation determines that a field should no longer contain a value:

Current behavior:

• Text → may require ' ' as a workaround.
• Enumeration → cannot reliably be cleared.
• Date → may only appear cleared after Save.
• Downstream null/empty checks may produce unexpected results.

Proposed behavior:

Calculation determines field should be empty
                ↓
        Set field to NULL
                ↓
Field is immediately displayed as empty
                ↓
isEmpty() / null / exists checks
correctly recognize the field as empty
                ↓
Behavior remains consistent after Save

Suggested Outcome

IBM OpenPages should provide a single, documented, consistent approach for clearing field values, regardless of the field type.

This would significantly simplify calculation development, improve the predictability of OpenPages behavior, reduce field-level workarounds, and provide a more consistent experience for both administrators and end users.