Data Tab


The Data Tab of the Configure [Node] Dialog Box allows you to perform various operations on your process data. It is accessed by right-clicking on a node and selecting Properties. This tab has different property sheets displayed on the Inputs Tab and the Outputs Tab. The Inputs Tab is displayed by default.

See also: Expressions

Node Inputs

Appian Smart Services include node inputs that have already been created to help you configure the activity. These cannot be deleted.

Node inputs can be saved into process variables for use in other nodes, or they can provide data for the node to process.

  • There is no guarantee as to the order in which expressions for node input values will be evaluated. It should be assumed that they are evaluated simultaneously. Therefore, you should not use or reference node inputs in an expression for the Value field of another node input within the same node.

If you are using a form, the form field values can be saved into node inputs, which appear on the Inputs tab.

  • Expressions for node input values are evaluated before expressions on the form. If the default values of form fields are mapped to node inputs, then they are evaluated at the same time as the node inputs. Therefore, they must not reference other node inputs.

Any node inputs that you create on the Data Tab automatically generate form fields if you've assigned the activity to anyone as a task. Should you need to specify the value of a node input for an assigned activity, open the form and delete the associated field. This enables you to specify a value in the field, which is otherwise disabled when a form is being used (displaying the words From Form instead of an editable field).

Creating Node Inputs

The Data Tab allows you to create node inputs that are standard Appian data types or custom data types. You must create node inputs (activity class parameters) and save the node inputs into process variables if you want to use their values elsewhere in the process.

Creating a Node Input

  1. Click New Input.
    • A new node input is listed, and its properties are displayed.
  2. Under Field Properties, type the name of the input.
  3. Select the data type of the node input in the Type field.
    • You can select from a list of available data types by clicking the Browse button.
    • Only custom data types that are made available to pickers are shown. See also: Custom Data Types.
    • Selecting a custom data type changes the node input from a single name into the expandable hierarchy of fields that exist in the data type. Complex_node_input.gif
  4. If you need to store multiple values in the same node input, select the Multiple checkbox under Field Properties.
  5. To specify a value type it in the Value field, or select the Expression Editor button to assign a value to the field from an expression.
    • For complex CDTs, select each child element to display its individual value field.
  6. If the node must take a value for the input before completing, select the Required checkbox.

If you intend to change a node input's value before storing it in a process variable, bypass the Save Into field on the node input properties when saving the value by completing the following:

  1. Click the Outputs tab.
  2. Click New Custom Output.
  3. Create an expression that references the ACP (node input).
  4. Save the node output into a process variable.

Creating Node Inputs from Query Rules

One way to use data from a data store in your process is to map a query rule to a node input.

  1. Create a query rule that selects the desired data from a data store entity.
  2. In your process model, on the data tab of an activity, create a new node input.
  3. In the Type field, select the data type of the Data Store entity used by your query rule. Data_store_entity_data_type.gif
  4. Select the Multiple checkbox. The node input must accept multiple values, unless you expect the query rule to return only one record.
  5. If the activity is attended, the Value field is unavailable, listing From Form as its value. Open the activity's form and delete the most-recently added form field.
    • The Value field is enabled.
  6. In the Value field, click the Expression Editor button, and select the Rules & Constants tab.
  7. Select the rules folder where your query rule is saved.
  8. Select the query rule you want to use to populate the node input, and click OK.

Saving Node Inputs to Process Variables

You can save the value of the node input into a process variable of the same data type and cardinality (whether or not the variable accepts multiple values) using the Save Into field that appears on the property sheet associated with the node input. If the PV has the same data type but stores multiple values, it does not appear on the Save Into list. If so, you must use a node output to update the PV with your node input data.

If the process variable has already been created, you can select it from a list by clicking the field or the arrow next to the Save Into field - OR - click New_process_variable_button.gif to create a new process variable.
The data type of the process variable you create cannot be changed. It is automatically assigned the same data type as the node input. (Mapping data from one data type to another is only supported for Date, Time, and Date/Time data types, which are interchangeable.) You cannot store a value in a process variable and use that updated value within an expression in the same node. This must be done in a subsequent node. Node inputs and node outputs don't necessarily execute in the same order that they appear on their respective property sheets.

NOTE: Values entered into a form are only saved into their configured process variables when the user submits the form. As a result, you cannot report on values entered into a form which is saved but not submitted.

Saving Data from Custom Data Types

When saving a value from a custom data type, you have a number of options. - Save the entire data set into a complex process variable. - Save individual elements into a complex process variable. - Save individual elements into a process variable with a system type.

Saving the Entire Data Set

  1. Select the parent node of the custom data type. For example, given a custom node input with the following structure, select Person.

    Person (NewComplexDataType)
        |- FirstName (Text)
        |- MiddleName (Text)
        |- LastName (Text)
  2. Click New_process_variable_button.gif to create a new process variable.

    • This PV is of the same data type as your node input and can hold either multiple values or a single value.
    • The new PV appears in the Save Into Field.
      Saving Individual Elements into a Complex Process Variable

You can save the value from a child element of your node input into a child element of a matching complex PV. The PV must match the node input (both the data type and whether it accepts multiple values). 1. Select the child element in your custom node input that you want to save. - Its field properties are displayed. 1. In the Save Into field, select an existing (and matching) complex PV. 1. Drill down to the desired field in the PV that you want to hold your node input data. Save_into_cdt_node_input.gif

Saving Individual Elements into a Standard or Simple Process Variable

  1. Select a child element of the custom data type. For example, given a custom node input with the following structure, select FirstName. Person (NewComplexDataType) |- FirstName (Text) |- MiddleName (Text) |- LastName (Text)
  2. Click New_process_variable_button.gif to create a new process variable.
    • This PV is of the same data type as the child element of the node input. In our example, the new PV takes a text data type.
    • The new PV appears in the Save Into field. Node outputs offer greater flexibility for saving node input values into process variables. You can append a value to a multiple value process variable, insert a value into a specific index, and modify your data using expressions.

Deleting a Node Input

Select the node input and click the Delete Input button. Only node inputs that you create can be deleted. Required node inputs cannot.

Node Outputs

Node outputs can be used to store the data processed by your node using an expression. For example, uploading a document generates a document ID. Any result values (also called Activity Classes) handled by a node are displayed on the Outputs Tab.

You can also use custom node outputs to change data using expressions, append data to multiple-value process variables, and update specific index values in a multiple value PV.

Saving Results into Process Variables

Many Smart Services automatically generate result data that can be mapped to process variables (PVs). If a result is available, it appears on the minimizable result list on the Outputs property sheet on the Data Tab.

  1. Select a result to display its properties. Result_property_sheet.gif
  2. Select an existing variable from the Target List - OR - click New_process_variable_button.gif to create a new variable.
    • A preconfigured result that has a single value can only be stored as a single-value PV (using the is stored as operator).
    • Multiple results can be stored as multiple-value PVs, or appended to a list of multiple PVs.
    • Single-value preconfigured results cannot be appended to a list of multiple-value PVs.
    • Use Custom Output expressions to append a single return value to a multiple value process variable with a compatible data type.

Creating a Custom Node Output

Custom node outputs provide a more flexible way to handle data than node inputs. All process variables in the process model are available the Target field, instead of only matching data types (the matching cardinality restriction, which normally requires matching between multiple versus single value variables, is also dropped).

  1. Select the Outputs Property Sheet of the Data tab.
  2. Click New Custom Output.
    • An item is added to the node output list, and the Expression Properties are displayed.
  3. In the Expression... Field type a logical expression that is evaluated during run-time, or click expression-editor.gif to build your output logic using the Expression Editor.
    • Any node inputs that you have configured are listed on the Expression Editor's Data tab under Activity Class Parameters. Ee_node_inputs.gif
    • If the node input has a custom data type, you can expand it to select a child element. Ee_complex_node_inputs.gif
  4. Skip over the operator field for now, and select the process variable to store your output from the Target list.
    • If the process variable has a custom data type, you can also select child elements from a context-sensitive list.
  5. If the process variable does not yet exist, click New_process_variable_button.gif to create a new process variable.
  6. Select one of the following options from the Operator list. This list varies according to the data type of the target process variable. All data types allow you to use the following operators:
    • is stored as
    • is stored at index
    • is appended to list
    • If the output is mapped to a process variable with a number or decimal data type, the following additional operators are enabled:
      • is added to
      • is subtracted from
      • is multiplied by
      • is divided into
      • is the power to exponentiate NOTE: This option is deprecated functionality.
  7. If a process variable has an existing value, the value saved equals the result of the combination of values made using the specified operator.
  8. If you store a single value in a multiple value PV, the single value replaces all existing values.
  9. If you append to a field of a multiple PV, the other undefined fields of that PV assume that you are passing null values.
    • For example, if a complex process variable named PC contains elements named CPU and RAM, appending a value into only PC.CPU also stores a null value into PC.RAM for the same item in the list.
    • Keep this in mind if you want multiple field values appended into the same item in a multiple PV.

Appending Values into a Complex Array

To add values into different fields of a complex array, you must append them within the same activity. Otherwise, new items are added when each field is saved (leaving other fields blank) — when you typically want to store data in all the fields of a single item.

You can append multiple fields into the same item using an expression; or you can create a custom output for each field you want to save. - For instance, you could append two (or more) values into the same item using an expression similar to the following example.
- Expression={CPU:"Intel Xeon", RAM:"4GB"} - Operator=is appended to list - Target=PC

  • It is also possible to append values into the same item by creating custom outputs for each field value, which are assigned to the correct fields by drilling down within the Target list. Data_Tab_output.png

Node Output Errors

If a single node output encounters an error that prevents it from writing its value to a process variable, none of the node outputs are written.

For example, if you use an expression that accesses information about an object, and the current user doesn't have the right to access that object, then an error occurs.

  • The node output does not write any data from the expression to its mapped process variable.
  • Also, no other outputs from this activity write process variable data.

Inserting a Value into an Index of an Array

  • When a node output is mapped to a multiple value process variable, the following additional operator is enabled. is stored at index
  • To specify the array index that you want to update: Type its number, or create an expression that results in the index value.
  • To perform calculations on a node output, first select (or create) a target process variable with a data type of Integer or Decimal before selecting an operator from the list.

Multiple Node Instances and the tp!instanceIndex Property

If you are executing the activity using Multiple Node Instances, consider the following:

  • Do not use the is stored at index operator together with the tp!instanceIndex property when performing these operations.
  • The is stored as operator can be used instead, when you spawn the same number of instances as the number of items in the process variable that you're saving into.
    • The system automatically uses the tp!instanceIndex property when assigning values; the value of your expression is stored at pv!yourArray[tp!instanceIndex].
  • If your target variable has no items, use the is appended to list operator.
    • If you choose to Run instances one at a time, you can guarantee the MNI instances execute in the same order as the array passed in.
  • If you want to insert the same value into multiple indices, use the updatearray() function with the is stored as operator.
  • The same applies for if you want to use is stored at index in conjunction with MNI.
    • Use the updatearray() function with the is stored as operator.

See also: Multiple Node Instances

Saving Values from Nested Arrays of an Array

To save values from a nested array of custom data type, you must save the parent object into a process variable (PV).

  1. Select the parent (or root) element or record of the unavailable nested array. Nested_multiples_node_outputs.gif
    • The Result Properties are displayed (for a node output) or the Field Properties are displayed (for a node input).
    • While the interface may state that there is "No Support for Nested Multiples", this only refers to the ability to view the complex structure and select a specific nested element.
    • You can save data from the variables or elements that contain nested multiple elements, provided the data structures match.
    • Selecting the parent element allows you to save values from a nested multiple.
  2. Click New_process_variable_button.gif.
    • The New Process Variable Dialog Box is displayed.
    • The Type Field is disabled and lists the data type of the element or record that you are saving.
  3. Ensure that the Multiple Values selection is retained.
  4. Name your process variable and click OK.

On This Page