From Messy to Maintained: Leveraging Arcade for Better Address Data

Maintaining accurate and consistent address data is essential for local governments, utilities, and emergency response systems—especially as many agencies work toward compliance with Next Generation 9-1-1 (NG9-1-1) standards. One powerful tool within ArcGIS Pro that can help streamline address and road centerline data management is Arcade, a lightweight expression language designed specifically for use within the ArcGIS platform.

Within ArcGIS Pro, Arcade allows users to create logic-based expressions for many different tasks, such as field calculations, attribute rules, and labeling. Arcade’s flexibility and ease of use can help automate data entry and updates, quality control, and visualization.

Applying Arcade to Address Data

NG9-1-1 Field Standardization

Arcade is particularly useful when working with NG9-1-1 datasets that require standardized identifiers, naming conventions, and data completeness. One example is using the Template Literals to calculate NGUIDs as a formatted string for address points and road centerlines:

SSAP16275@co.redfern.wi.us for Site/Structure Address Points

`SSAP${$feature[‘OBJECTID’]}@co.yourcounty.il.us`

RCL16275@co.redfern.wi.us for Road Centerlines

`RCL${$feature[‘OBJECTID’]}@co.yourcounty.il.us`

To ensure consistency across address fields, simple expressions can enforce title casing and uppercase formatting. This can be achieved by using the Proper and/or Upper functions:

Proper($feature[‘Municipality’]);    // Converts text to Title Case  

Upper($feature[‘MSAGcommunity’]);    // Converts text to UPPERCASE

These are helpful for aligning data with state formatting standards.

Constructing Full Street Names

Address datasets often store components like street prefix, name, type, and direction in separate fields. Arcade makes it easy to concatenate these parts into a single, full street name while filtering out nulls and empty strings:

// Initialize an index counter for the array
var i = 0;
// Initialize an empty array to store the parts of the street name
var features = [];
// Define a helper function to check the value and add it to the array if it's not empty or just a space
function addvalue(feat) {
    // If the value is empty or a single space, set it to Null
    if (IsEmpty(feat) || feat == ' ') { 
        feat = Null; 
    }
    // If the value is not Null, add it to the array and increment the index
    else { 
        features[i++] = feat; 
    }
}
// Add each component of the full street name to the array
addvalue($feature['st_premod']);  
addvalue($feature['st_predir']);  
addvalue($feature['st_pretyp']);   
addvalue($feature['st_presep']);   
addvalue($feature['st_name']);     
addvalue($feature['st_postyp']);   
addvalue($feature['st_posdir']);   
// Concatenate the valid parts of the street name into a single string with spaces between them
var vals = Concatenate(features, " ");
// Return the full street name if not empty, otherwise return Null
return IsEmpty(vals) ? Null : vals;

If your state requires a full street name field, this expression builds a clean, standardized value.

Calculating Parity

Parity, in the realm of addressing, refers to whether address numbers on a given side of the road are odd, even, both, or unknown. Maintaining correct parity on road centerline features is especially important for validating address ranges. Arcade can calculate parity using basic logic and the modulus operator:

// Get the 'from' and 'to' address values from the left side of the road
var L1 = $feature['fromaddr_l'];
var L2 = $feature['toaddr_l'];
// Initialize variables for parity calculation
var LP = '';   // Final parity result
var L1v = '';  // Parity of L1: 'E' or 'O'
var L2v = '';  // Parity of L2: 'E' or 'O'
// Check if both values are either zero or empty
if ((L1 == 0 && L2 == 0) || (IsEmpty(L1) && IsEmpty(L2))) {
    LP = 'Z'; // Assign 'Z' for "Unknown" parity
} else {
    // Determine if L1 is Even ('E') or Odd ('O')
    L1v = (L1 % 2 == 0) ? 'E' : 'O';
    // Determine if L2 is Even ('E') or Odd ('O')
    L2v = (L2 % 2 == 0) ? 'E' : 'O';
    // Combine both parity values (e.g., "O,E" or "E,E")
    LP = Concatenate(L1v, ',', L2v);
    // If parities are mixed (one Even, one Odd), label as 'B' for Both
    // Otherwise, use the parity of L1 (since both are same)
    LP = (LP == 'O,E' || LP == 'E,O') ? 'B' : L1v;
}
// Return the final parity value
return LP;

This logic returns 'O', 'E', 'B', or 'Z' based on the values of the address range.

Attribute Rules: Automating and Validating Data

Arcade is the hidden magic behind Attribute Rules in ArcGIS Pro. The rules help automate calculations of field values and help find data quality issues at the feature level. The two most commonly used types of Attribute Rules, Calculation and Validation, are especially useful for address maintenance.

Calculation Rules

Calculation Rules automatically populate fields when data is added or edited. Expressions that you might otherwise use for field calculations can be added as calculation rules to streamline data entry and updates.

Validation Rules

Validation Rules check whether required fields are filled in or if values meet specific conditions. These rules help ensure quality by flagging data inconsistencies that might otherwise go unnoticed.

Examples:

Missing address number in Address Points:

// Get the address number value from the feature
var apAddNum = $feature[‘add_number’];
// Check if the address number is either 0 or empty
// If it is, return false (flag for error), otherwise, return true (no error)
IIf((apAddNum == 0) || IsEmpty(apAddNum), false, true);

Missing street name in Road Centerlines:

// Get the street name from the feature
var rclStName = $feature['st_name'];
// If street name is empty, flag for error
return !IsEmpty(rclStName);

These checks help prevent incomplete records in NG9-1-1 datasets.

Validation rules can detect a variety of issues; the possibilities are endless. For example, you can set up expressions to flag:

• Address ranges where the “from” value is greater than the “to” value

• Duplicate address points

• Parity inconsistencies

• Range overlaps

• Domain violations

Labeling to Surface Issues Visually

Arcade expressions can also be used with labeling, making it easier to identify issues directly on the map by summarizing relevant address components. This helps editors visually inspect data for completeness and accuracy.

Address Point Label Example:

$feature[‘Add_Number’] + TextFormatting.NewLine +
$feature[‘FullStNm’] + TextFormatting.NewLine +
$feature[‘Post_Comm’]

To enhance this expression, you can use \n with a template literal to avoid having to manually add TextFormatting.NewLine:

`${$feature[‘Add_Number’]} ${$feature[‘FullStNm’]}\n${$feature[‘Post_Comm’]}`

Or you can just enter a new line with the Enter key to get the same result as a multiline literal:

`${$feature[‘Add_Number’]} ${$feature[‘FullStNm’]}
${$feature[‘Post_Comm’]}`

Road Centerline Label Example:

`L: ${$feature['FromAddr_L']} - ${$feature['ToAddr_L']}\nR: ${$feature['FromAddr_R']} - ${$feature['ToAddr_R']}\n${$feature['FullStNm']}\n${$feature['PostComm_L']

OR

`L: ${$feature['FromAddr_L']} - ${$feature['ToAddr_L']}
R: ${$feature['FromAddr_R']} - ${$feature['ToAddr_R']}
${$feature['FullStNm']}\n${$feature['PostComm_L']}`

These labels provide a quick snapshot of range and naming data, making it easier to spot missing or inconsistent values during editing.

Conclusion

Esri’s Arcade expression language offers a powerful set of tools for improving the quality and consistency of address data in ArcGIS Pro. From field calculations and formatting to automation, quality control, and labeling, Arcade supports more efficient workflows and reduces the risk of data errors—which can help with NG9-1-1 compliance.

The examples above are just a few ways you can incorporate Arcade into your data management practices. Doing so can lead to cleaner, more reliable address datasets that support efficient emergency response time and public safety.