APPIAN

Question: What are the Interfaces available in Appian?

Answer: For Basic User Tempo (/suite/tempo), Sites (/suite/sites/<sitename>), and Embedded Interfaces.
Question: Can you explain the purpose of each tab in Tempo?
Answer:
News allows the users to collaborate among themselves to complete their work. The news tab allows the
users to Post an Event or Message or Send Task or Kudos. The source of the data can be process and Users. If
the User sends a Task through news then that task will be visible to the Group or person in their Tasks tab.
Tasks allow the users to take the workflow to the further steps in a process instance.
Records shows the data related to specific entity or from multiple entities giving the user more details.
For example in Patient record the data might display as Patient data and the surgeon details who performed
procedure information etc.
Reports display data in an aggregated format from multiple entities providing a graphical representation of
the data using Grids, Pie Chart, Bar Chart, Line Chart or Column Chart. User can go in deep of the report to see
the more information on the data. The source of data might be Databases, Records, Process Analytics or Third
Party Systems.
Actions allows the user to create a new data into the system. Actions can be grouped by Application. The use
should have proper security rights to see the Action.
Question: What are Sites and when can we go for Sites?
Answer: Sites is one of the Basic User interface. Sites allow the Designers to configure the specific tabs of
tempo like Records, Reports and Actions. In this ways the users who need to access only one tab can be
provided security for that tab for f corresponding Group so that can work on it and complete their job. Unlike
Tempo, when we want to display only set of tabs (Records, Reports and Actions) in Appian We can go for
sites.
We can set the visibility for the each tab in Sites to set of User groups. Each tab we use to call as a page and in
each page we can display Record Type or Report or Action. Maximum 5 pages are allowed in Sites.
Question: What can we display in Sites?
Answer: We can configure Record, Reports and Actions. Records means a Record list for particular Record
type. Suppose the organization has many record types displayed in Records tab and we can configure
particular record type to display. E.g. Patients, Doctors, Anaesthesiologists etc
Question: What are embedded Interfaces?
Answer: Designers can configure the Appian User interfaces in their corporate portal such Interfaces are
Embedded Interfaces.
Question: What is SAIL?
Answer: Appian SAIL (Self-Assembling Interface Layer) is the patented framework that takes declarative UI
definitions to generate dynamic, interactive, and multi-platform user experiences.
Question: What are different Layouts available in Appian?
Answer:
Billboard Layout - Displays a background colour, image, or video with optional overlay content.
Box Layout - Displays any arrangement of layouts and components within a box on an interface.
Card Layout - Displays any arrangement of layouts and components within a card on an interface. Can be
styled or linked.
Columns Layout - Displays any number of columns alongside each other. On narrow screens and mobile
devices, columns are stacked.
Dashboard Layout - Displays any arrangement of layouts and components. Use this as the top-level layout for
record views and Tempo reports.
Form Layout - Displays any arrangement of layouts and components beneath a title and above buttons. Use
this as the top-level layout for start and task forms.
Section Layout - Displays any arrangement of layouts and components beneath a section title on an interface.
 APPIAN
Side By Side Layout - Displays components alongside each other.
Question: What are different Inputs available in Appian?
Answer:
Barcode - Displays a field that allows entry of a barcode value using a barcode scanner or manual input.
Date - Displays and allows entry of a single date (year, month, day). When the field is editable, users can input
dates by typing or by picking from a calendar.
Date and Time - Displays and allows entry of a single date and time (year, month, day, hour, minute, second).
When the field is editable, users can input dates by typing or by picking from a calendar and then select the
time from a dropdown.
Decimal (Floating Point) - Displays and allows entry of a single decimal number, stored with a floating point
representation.
Encrypted Text - Allows entry of a single line of text that is encrypted when saved into a variable.
File Upload - Allows users to upload a file.
Integer - Displays and allows entry of a single integer number.
Paragraph - Displays and allows entry of multiple lines of text.
Text - Displays and allows entry of a single line of text.
Question: How many types of Records available in Appian?
Answer: Entity Backed, Process Backed and Expression Backed or Service backed records.
Question: Can you explain Entity Backed Records?
Answer: The Records that is displayed from database entities are called entity backed records. The underlying
entity might be a single table or a view that is created on joining of multiple tables.
Question: Can you explain Process Backed records?
Answer: The Records that is displayed from Process Instances are called Process backed records.
Question: Can you explain Expression Backed records?
Answer: Records that are displayed from an expression are called Expression backed records. The Expression
will call a service and pulls the data from external system.
Question: What is records Related Actions and what is the purpose of Related Actions?
Answer: Related Actions allows the users to act upon on existing context of the data. For Example for a
patient record if the surgeon wants to schedule a Surgery based on the existing context of the patient data.
We can set the security for the related actions so that the other users cannot act upon the existing data and
only specific set of users can act on it.
Question: What types of Reports available in Appian?
Answer: Tempo Reports and Process Reports (Portal reports). Tempo reports display data from different
types of sources like databases, Records, Process Analytics and Third Party systems in the form of Grids, Pie
charts, Bar charts, Line Charts and Column Charts. Process reports are used to display the data regarding
Process instances. These data will be displayed in terms of Grids.
Question: What are the different Pickers available in Appian?
Answer:
Custom Picker - Displays an autocompleting input for the selection of one or more items from an arbitrary
data set.
Document Picker - Displays an autocompleting input for the selection of one or more documents.
Document and Folder Picker - Displays an autocompleting input for the selection of one or more documents or
folders.
Folder Picker - Displays an auto completing input for selecting one or more folders.
Group Picker - Displays an auto completing input for selecting one or more groups.
Record Picker - Displays an auto completing input for the selection of one or more records, filtered by a single
record type. Suggestions and picker tokens use the title of the record.
User Picker - Displays an auto completing input for the selection of one or more users.
User and Group Picker - Displays an auto completing input for selecting one or more users or groups.
 APPIAN

Question: When can you go for Radio button, Checkbox field and Drop down field and Multiple drop down
field?
Answer: Radio Buttons allows the user selecting only one option among the list of options.
Check boxes allows the user selecting more than one option among the list of Options.
Drop down filed displays the values allowing the user to select one option from them.
Multiple Drop down filed displays the values allowing the user to select one option from them.
When we have very less values to display like 5 or 6 then we can go for Radio buttons and check box fields.
If we want to display more number of values then we can go for Drop down field and Multiple Drop down
fields so that the form space will be utilized effectively.
Question: What are different types of Link fields available in Appian?
Answer:
Authorization Link - Defines a link to authorize a user for a connected system that uses OAuth 2.0.
Document Download Link - Defines a link used to download a document.
Dynamic Link - Defines a link that triggers updates to one or more variables.
News Entry Link - Defines a link to news entries.
Process Task Link - Defines a link to a process task.
Record Link - Defines a link to a record view.
Report Link - Defines a link to a report.
Start Process Link - Defines a link to start a process and navigates the user through any initial chained forms.
Submit Link - Defines a link to trigger form submission.
User Record Link - Defines a link to a user record.
Web Link - Defines a link to an external web page.
Question: Can you explain few link fields?
Answer:

Web Link:
a!safeLink(
label: "Company web site",
uri: "http://www.appian.com"
)
Document Link:
a! documentDownloadLink(
label: "Image",
document: toDocument(2565)/*2565 is a document Id */
)
Submit Link:
a!submitLink(
label: "Delete Request",
confirmHeader: "Warning!",
confirmMessage: "This request will be permanently deleted. Do you want to
continue?",
confirmButtonLabel: "Delete Request",
confirmButtonStyle: "DESTRUCTIVE",
cancelButtonLabel: "Cancel"
)
 APPIAN

Start Process Link:

a!startProcessLink(
label: "Update Customer Details",
processModel: cons!UPDATE_CUSTOMER_DETAILS_PM,/*Process Model Constant*/
processParameters: {
customerId: ri!customer.id
},
bannerMessage: "Updated details for " & ri!customer.name
)
Record Link
a!recordLink(
label: "Employee",
recordType: cons!EMPLOYEE_RECORD,/*Record Constant*/
identifier: "5"
)

Question: What is the difference between button widget and button widget submit?
Answer:
Button widget - Displays a button that can conditionally be used to submit a form. Buttons must be placed
inside a button layout.
Button widget Submit - Displays a button that submits a form. Buttons must be placed inside a button layout
Question: What are different types of Grids available in Appian and what is the difference between them?
Answer: There are two types of Grids available in Appian Paging Grid and Editable Grid.
Paging grid - displays the data in a tabular format with pagination at the bottom right corner of the grid and
all the fields are read only. Designer can configure selection on the pagination. Paging grid can be created by
a!gridField.
Editable grid – displays the data in a tabular format allowing the user to edit the field’s inline. It will not have a
pagination. Editable grid can be created by using a!gridLayout.
Question: What is the difference between load and with?
Answer:
Load variables will be initialized With variables will be recalculated each time
once the form is loaded and re- when the expression is re-evaluated.
evaluated each time with the
existing values.

We can use load variables in We can use load variables in SaveInto and
SaveInto and a!Save() a!Save()
We cannot use apply function We can use apply function when calling rule
when calling rule has load has With

Question: What are Data Stores and what is the purpose of Data Stores in Appian?
Answer: Data stores connect the appian to external relational database to Appian. We can connect to only
Secondary data bases and those are configured in JNDI Data source. The Data Stores should have proper
security configured else the writes and reads will throw error.
 APPIAN
Question: What are the difference between Query Rule, Query Entity and Query Record.
Answer:
Query Rules a!queryEntity() queryrecord()
Performance Medium Fastest Slowest
Columns Retrieves all columns Retrieves only the Retrieves only the
specified columns specified columns
Aggregations None COUNT, SUM, AVG, MIN, COUNT, SUM, AVG, MIN,
MAX MAX
Can Retrieve Unique Values No Yes Yes
"Between","Not Includes", No Yes Yes
"Not Starts With","Not
Ends With","Is Null","Not
Null,OR, Nested Filters
Sorting on a list field Yes No No
Sorting on multiple fields Yes Yes No
Return Type an Array of CDTs or a DataSubset of DataSubset of Dictionaries
DataSubset of CDTs Dictionaries

Source Data Data Store Entity Data Store Entity Process-backed and
entity-backed records.
Any default filters for the
record type are applied.

Question: Will it be possible to get data from Database based on the grouping of a certain column?
Answer: Yes we can use isgrouping attribute in Query Aggregation column.

a!queryAggregationColumn(
field: "department",
isGrouping: true
)

Question: What is the difference between Apply and Applycomponents?

Answer:
apply() function call a rule or applycomponents()function Calls a rule or
function for each item in list and function for each item in a list and supports
provides any context specified. the preservation of the local state on
interfaces.

apply() cannot be used with rules applycomponents() can be used with rules or
or functions that store local data, functions that store local data, including
including rules using load() rules using load()

The Function which was called by The Function which was called by
Apply should not contain SAIL applycomponents can contain SAIL
components components

Question: What is Process Model and Process Instance?

Answer: A Process Model is like a java Class and Process instance is like an Object for each class there can
have many objects like wise for a Process Model there can have Multiple Process Instances.
 APPIAN
Question: What is Process Modler Analyst View and Designer View?
Answer: Analyst view will be designed by Business Analyst which contains high level flow of the process, Here
we first check what are the order of events, decision points and who are the actors involved.
 We cannot create Process Variables i.e. Properties tab will not visible.
 We cannot configure Inputs and outputs of Script task, we can just drag and drop the node, name that
node based on the functionality does.
 Cannot set security.
 Can enable Activity Chaining
 Cannot configure subprocess.
Question: What are the different ways to get the data into Appian from Database?
Answer:
 We can get data from Database to Appian via Query Rules.
 We can get data from Database to Appian via Query Entities
 We can get data from Database to Appian via Query Database smart service.
 We can get data from Database to Appian via Execute stored procedure smart service.
 We can get data from Database to Appian via External Service.
Question: How many ways a CDT can be created in Appian?
Answer:
 Using Data Type Designer.
 Importing an XSD
 Importing a CDT from other Environment.
 Calling WSDL service using Call web service smart service
 Custom Java plugin
Question: Can you explain the different gate ways available in Appian and its purpose?
Answer:
XOR gate way is like if else conditions among the multiple outgoing paths only one outgoing path will be
execute based on the condition
OR gate way is like if conditions the conditions that become true those outgoing paths will be executed hence
there can be multiple outgoing paths executed.
AND gate way is like fork and join. And gate way will wait for all the incoming paths to reach the node once all
the incoming paths reaches the node then all the outgoing paths will be executed simultaneously.
And gate way doesn’t require any configurations.
Complex gate way is a combination of all the above gate ways.
Question: What are types of sub processes available in Appian?
Answer: There two types of sub processes available in Appian i.e. Synchronous and Asynchronous.
Question: What is the Use of Exceptions and Escalations?
Answer:
Exceptions The exceptions tab lets designers create alternative workflows from an activity based on
configured conditions. The exception tab appears on all non-event and non-gateway activities. We can
configure the Exceptions based on Timer Event, Rule Event and Receive Message Event.
Escalations It is like SLA when a task or process node is delayed for any reason, configurations in the
escalations tab can automatically take a number of actions to solve the problem. We can configure a timer
event and change raise the priority or send an Alert or Send a Message or Reassign a Task.
 APPIAN
Question: What are the differences between Synchronous and Asynchronous Sub process?
In synchronous sub process the In Asynchronous sub process the parent
parent process waits for the child process will not wait for the child process to
process to complete. complete, the parent process starts the child
process and completes with its flow.

Contains both Inputs and Outputs Only Input tab will be present so that the
so the parent process can take the parent process can send the data to the child
processed data from the child process.
process.

They do allow activity-chaining into They do not allow activity-chaining into a

a child process from the parent child process from the parent process
process

Question: What are different types of Events available in Appian and its purpose?
Answer:
Start Event node denotes the beginning of a process in a process model, and is used to configure how a
process is launched. The system only allows you to use one Start Event per process model. We can configure
Receive Message Event and Timer Event.
End Event (without a trigger) is used to denote the end of a process flow within a process model. The process
remains active until all active paths in the process arrive at an end event.A process model can have multiple
End Events.
Send Message In a process, a Send Message event can be used to generate a message that is made available
to all Receive Message events (which are actively listening for messages). Messages sent to events that are
not active (either paused, yet to be activated, passed in the process flow, or in an unpublished process model)
are discarded.
Receive Message In a process, a Java message or an email can be used to send information to your process
flow. The Receive Message event can consume an action, or it can be configured to act within a smart service
activity (to trigger an Exception Flow).
Timer events can either be added to the process flow by themselves, or they can be added within an Appian
Smart Service to trigger an Exception Flow or an Escalation. In the process flow, timer events can be used to
schedule a process activity, or to only continue the flow when certain conditions are met. (If the event is
configured in an escalation or an exception, the configuration settings list different wordings.)
The delay or schedule added to an activity or a process flow only begins once the node or event has been
activated.
The timer event must be active in order for the schedule to be triggered. If an End Event is configured to
terminate the process, the timer is also terminated
Rule Event At any time in a process model when there are certain conditions that need to be met before the
process flow proceeds, an intermediate rule event should be used. Once an intermediate rule event is
activated, it remains active until the rule evaluates to true.
Question: What is activity chaining?
Answer: Activity chaining is used when the same user wants to complete two user inputs task one after other
if we enable activity chaining between these two user input tasks then after submitting the form in first user
input task then immediately second form will be displayed to the same user, if we don’t enable the activity
chaining then after submitting the first form then the second task will appear in Tasks Tab.
 APPIAN
Long activity chains - greater than 50 node instances OR 5 seconds between attended activities - are strongly
discouraged because they have both an adverse effect on the performance of the system at scale and the
experience of the user.
Question: What is the difference between End Event and Terminate Event?
Answer:
 An End Event (without a trigger) is used to denote the end of a process flow within a process model.
The process remains active until all active paths in the process arrive at an end event. Until all the
active paths reaches the End event the process will still in Active state
 A process can have multiple End Events. If so, the different branches of a process remain active until
each active path reaches one of the multiple End Event nodes. In such cases, a Terminate Process
event can be used to stop all branches of a process, even if one or more branches have not yet
reached an End Event node. If any of the active path reaches the Terminate Event then the Process
will be in completed state.
Question: What is the Use of Data Management Tab and Alerts tab?
Answer:
Data Management All Appian processes, including completed and cancelled processes, are retained in
memory until archived or deleted. The settings on the data management tab allow designers to specify a
policy for archiving or deleting completed and cancelled processes.
By default, the process is automatically archived after 7 days. Any changes made on this form are applied to
all completed instances of the Process Model. Sub-processes do not inherit this setting.
Alerts The alerts tab specifies the recipients of an alert if there is an error in the process. Generally we use to
configure Application Administrators Group in Alerts tab.
Question: What is Quick Task?
Answer: A Quick Task is any attended activity that is activated by itself and completed outside of fixed process
flow. They are initiated on an ad-hoc basis and a new instance of the task is automatically generated after one
is completed. All assignees can view and complete the Quick Task any number of times until the completion or
termination of the process.
Any attended process activity can be configured as a Quick Task. Such activities display the following marker.
Like other tasks, quick tasks are not required to have an incoming flow, but they must have an outgoing flow.
If a quick task does not have an incoming flow it is activated immediately upon startup of the process.
Question: Can you explain the Security in Appian.
Answer: Security plays a prominent role in Appian. All the application objects including Application can have
security. Thus End users can work properly limiting their access based on the groups they are part of. In
Appian always we need to set security based on Groups only.
Application security enables the users to restrict the access only to the applications that they are working on.
Within an Application based on security of the process models we can restrict the users to display Actions and
performing an Action only to the specific groups users part of.
Knowledge centre security allows the user to upload or download the documents .
Data Store security allows the user to persist the data in to the Database and Retrieve Data from the
Database.
Question: What is Process Start Form and how is it different from User Input task form?
Answer: Process start form allows the user to collect some data from the user to start the process. Untill the
user clicks on the submit button of a form or submit process link the Process will not be started. Where as in
User Input form the process started and been in an Intermediate state at User Input task until the User Clicks
on a button the Process will not continue with the next flow. To create an action in Sites the process model
should contain a process start from where as in Tempo this is not required.
 APPIAN
Question: How many ways a process model can be triggered or started?
Answer:
 From Application Action
 From Record Related Action
 From Submit Link or Button of a Process start form
 From sub process (Synchronous/Asynchronous)
 From Receive Message Event in Start Node
 From Timer Event in Start Node.
 Start process smart Service.
 Start Process smart function
 Start Process link
 Servlet
 Through External system (Exposing PM / Web Api)
 Through End Event
Question: What is Web API?
Answer: Web APIs provide a way to expose Appian data and services to outside systems.
Web APIs are created much like expression rules, however there are two main differences between them.
First Web APIs also include an end point that can be called by other systems. Second, a designer doesn't
configure rule inputs for Web APIs, instead passing values to the Web API via query parameters, headers, a
body, or any combination of the three.
Hence External systems will call the corresponding URL for the Web API providing the inputs in the form of
JSON. Then the Web API will execute the rule and provide the output back to the System
All the Web APIs are exposed as Rest full Web service.
All Web APIs must return an HTTP response (a!httpResponse())
Errors related to execution of Web APIs are present in “logs/design_errors.csv”
a!httpResponse() parameters – statusCode, headers, body.
a!httpRequest() parameters – URL, pathSegments, queryParameters, headers, body
a!toJson(value)
We can expose Process models as Web Service. When we do so, the service is exposed as WSDL service.

DB schema Best Practices

1. Annotations: when using join column annotation in your XSD, when you insert update data in your data
store using write to data store smart node, corresponding field will not update the stored values in output.
User query rule.
2. Keep CDT & Element name less than 27 characters. More than 27 gets truncated. This is primarily to
maintain compatibility with all other databases.
3. Column Types: if inferred column does not match with existing table’s column, then @column
annotation with columnDefinition attribute should be used.
4. Null values: Empty text variables are handled as empty string and not null values. This allows empty
strings to be inserted into data store. If corresponding column in RDMS is configured as “not null” then
database will not prevent the empty string to be inserted.
Tempo Best Practices
1. Do not use administrator account for posting: when using Post Comment to Feed Entry smart service or
Post Event to Feed Entry smart service, choose a real, named user as an author.
2. Make sure readers understand the importance of post quickly: Use first few words to convey the real
meaning.
3. Avoid scheduling hazard alerts on repeat: When using Post Hazard to feed entry, avoid using this node
on repeat.
4. Make sure your entry or comment does not exceed byte limit i.e. 4000 bytes.
 APPIAN

5. Use existing groups as recipients

DB Performances Best Practices
1. Reduce the size of the response: If there is more data than the query will take longer time to respond.
2. Use a!queryEntity() instead of query rule for better performance.
3. Minimize the number of calls: the more the number of calls are made to database, the longer time
interface takes to respond.
4. Do not use looping functions to execute db queries.
5. Use indexes wherever required: in the context of performance, indexes can improve data retrieval
speed by avoiding slow table scans. However indexes are slow write options.
Record level security for entity backed Best Practices
1. Manage Global Viewers: there might be a use case in which a user has to be given access to all records.
Associating user to each record is a cumbersome process. An alternative is to
a. Create a dummy user name that has characters that are not allowed in normal Appian usernames. (Ex.
GlobalViewersGroup!)
b. Associate user to every records by inserting a row in association table. Add this relationship
automatically when new record is inserted.
c. Update user record to check if loggedInUser is member of Global Viewers group.
Creating memory efficient Process models Best Practices
1. Modular design with sub-processes: try to break long processes by creating sub processes.
a. This is because sub processes can be archived as soon as they are completed.
b. Use terminate event where ever required to kill the processes based on the requirement.
c. When retrieving large data say from web service, consider isolating data to a sub process, and
archieving/deleting after process is completed. This way memory can be used efficiently.
d. Use db activity in a separate sub process and kill the instance immediately, reason being data is already
present in db.

Appian Functions
Array Functions
a!flatten() Coverts an array that contains nested arrays to a flat arrya
e.g. a!flatten(1)-1
a!flatten({1,2,3})-1,2,3
a!flatten(
{
1,2,3,
{4,5}
}
)--- 1,2,3,4,5
a!append() Appends a value or values to given array and returns resulting array.
a!append({1,2,3},{“chandra”,”sekhar”})—1,2,3,null,null
a!append({“ch”,”nd”},{1,2,3})- ch,nd,1,2,3
updateArray() Inserts new values or modifies existing values at the specified Index of a given array
and returns the resulting array
updatearray({“ch”,”se”},3,{1,2,3}) –ch,se,1,2,3
Index() returns array[Index], if it is valid else returns default value.
 APPIAN
Index({10,20,30,40},{1,2},{})
with(
local!cdt:{
{name:"ABC",id:101,sal:3000},
{name:"DEF",id:102,sal:4000},
{name:"GHI",id:103,sal:5000}
},
index(local!cdt,"name",{})
)
“ABC”;”DEF”;”GHI”
Insert() Inserts a value at a given index and returns the resulting array.
Insert({10,20,30},200,2)—10,200,20,30
Insert({10,20,30},200,4)--- 10,20,30,200
Insert ({10,20,30},200,5)--- 10,20,30,200
Insert always inserts the given value at end of the array if the specified index is >= length of the
resulting array. Update array will inserts null values in between them. Append will always appends
the value at the end of the give array.
Joinarray()Concatenates the elements of an array together into one string and inserts a string
separator between each element.
Joinarray({10,20,30},”+”)—“10+20+30”
Length() returns the count of non null values
Length({10,20,30,null,40})—4
Count() returns the count of the elements in the array including null values
Count({10,20,30,null,40})—5
Length() throws error if the variable is null where as count() will not throw error.
Remove() Removest he value at given index from an array and returns the resulting array.
Remove({10,20,30},4)—10,20,30
Remove({10,20,30,40},{1,4})—20,30
Remove({10,20,30},5)—error invalid range.
Reverse() Reverses an array.
Reverse({10,20,30})—{30,20,10}
Where() Returns the indices where the values in the input array are true.
Where({true,false,true})—1,3
Wherecontains() Receives one or more values and returns an array of indices that indicate the
position of the values within the array.
Wherecontains(20,{10,20,30})—2
Set Functions
Contains() Checks whether an array contains the value.
contains({10, 20, 30}, 20)- true
Difference()Returns the values in array1 and not in array2.
difference({10, 20, 30, 40}, {30, 40})—10,20
intersection() Returns only those elements that appear in all of the given arrays.
intersection({10, 20, 30}, {20, 30, 40})—20,30
Uninon()Returns all unique elements from the given arrays.
 APPIAN
union({10, 20, 30}, {20, 30, 40})—10,20,30,40
Conversion Functions
Displayvalue()Tries to match a value in a given array with a value at the same index in a replacement
array and returns either the value at the same index or a default value if the value is not found.
with(
local!weekDay:{"Sun","Mon","Tue","Wed","Thu","Fri","Sat"},
local!weekNo:{1,2,3,4,5,6,7},
displayvalue(4,local!weekNo,local!weekDay,"Not Found")
)
Returns “Wed”
ToString()Converts a value to Text. If an array is passed in, its values will be concatenated to form
one string. To preserve the original array structure, use touniformstring.
Tostring({1,2,3})--"1, 2, 3"
ToUniformString()Converts a value to Text, preserving the original scalar or array structure. To
concatenate the array into one string, see tostring.
touniformstring("John Doe 1060 West Addison Chicago", "IL",15)-- John Doe 1060 West Addison
Chicago; IL; 15