This documentation is archived and is not being maintained.

DataColumn.Expression Property

Gets or sets the expression used to filter rows, calculate the values in a column, or create an aggregate column.

Namespace: System.Data
Assembly: System.Data (in

property String^ Expression {
	String^ get ();
	void set (String^ value);

/** @property */
public String get_Expression ()

/** @property */
public void set_Expression (String value)

public function get Expression () : String

public function set Expression (value : String)

Property Value

An expression to calculate the value of a column, or create an aggregate column. The return type of an expression is determined by the DataType of the column.

Exception typeCondition


The AutoIncrement or Unique property is set to true.


When you are using the CONVERT function, the expression evaluates to a string, but the string does not contain a representation that can be converted to the type parameter.


When you are using the CONVERT function, the requested cast is not possible. See the Conversion function in the following section for detailed information about possible casts.


When you use the SUBSTRING function, the start argument is out of range.


When you use the SUBSTRING function, the length argument is out of range.


When you use the LEN function or the TRIM function, the expression does not evaluate to a string. This includes expressions that evaluate to Char.

One use of the Expression property is to create calculated columns. For example, to calculate a tax value, the unit price is multiplied by a tax rate of a specific region. Because tax rates vary from region to region, it would be impossible to put a single tax rate in a column; instead, the value is calculated using the Expression property, as shown in the Visual Basic code in the following section:

DataSet1.Tables("Products").Columns("tax").Expression = "UnitPrice * 0.086"

A second use is to create an aggregate column. Similar to a calculated value, an aggregate performs an operation based on the complete set of rows in the DataTable. A simple example is to count the number of rows returned in the set. This is the method you would use to count the number of transactions completed by a particular salesperson, as shown in this Visual Basic code:

 DataSet1.Tables("Orders").Columns("OrderCount").Expression = "Count(OrderID)"

Expression Syntax

When you create an expression, use the ColumnName property to refer to columns. For example, if the ColumnName for one column is "UnitPrice", and another "Quantity", the expression would be as follows:

"UnitPrice * Quantity"


If a column is used in an expression, then the expression is said to have a dependency on that column. If a dependent column is renamed or removed, no exception is thrown. An exception will be thrown when the now-broken expression column is accessed.

When you create an expression for a filter, enclose strings with single quotation marks:

"LastName = 'Jones'"

The following characters are special characters and must be escaped, as explained here, if they are used in a column name:

\n (newline)

\t (tab)

\r (carriage return)





















If a column name contains one of the previous characters, the name must be wrapped in brackets. For example to use a column named "Column#" in an expression, you would write "[Column#]":

Total * [Column#]

Because brackets are special characters, you must use a slash ("\") to escape the bracket, if it is part of a column name. For example, a column named "Column[]" would be written:

Total * [Column[\]]

(Only the second bracket must be escaped.)


User-defined values may be used within expressions to be compared with column values. String values should be enclosed within single quotation marks. Date values should be enclosed within pound signs (#). Decimals and scientific notation are permissible for numeric values. For example:

"FirstName = 'John'"

"Price <= 50.00"

"Birthdate < #1/31/82#"

For columns that contain enumeration values, cast the value to an integer data type. For example:

"EnumColumn = 5"


Concatenation is allowed using Boolean AND, OR, and NOT operators. You can use parentheses to group clauses and force precedence. The AND operator has precedence over other operators. For example:

(LastName = 'Smith' OR LastName = 'Jones') AND FirstName = 'John'

When you create comparison expressions, the following operators are allowed:









The following arithmetic operators are also supported in expressions:

+ (addition)

- (subtraction)

* (multiplication)

/ (division)

% (modulus)


To concatenate a string, use the + character. The value of the CaseSensitive property of the DataSet class determines whether string comparisons are case-sensitive. However, you can override that value with the CaseSensitive property of the DataTable class.


Both the * and % can be used interchangeably for wildcard characters in a LIKE comparison. If the string in a LIKE clause contains a * or %, those characters should be escaped in brackets ([]). If a bracket is in the clause, the bracket characters should be escaped in brackets (for example [[] or []]). A wildcard is allowed at the start and end of a pattern, or at the end of a pattern, or at the start of a pattern. For example:

"ItemName LIKE '*product*'"

"ItemName LIKE '*product'"

"ItemName LIKE 'product*'"

Wildcard characters are not allowed in the middle of a string. For example, 'te*xt' is not allowed.


A parent table may be referenced in an expression by prepending the column name with Parent. For example, the Parent.Price references the parent table's column named Price.

A column in a child table may be referenced in an expression by prepending the column name with Child. However, because child relationships may return multiple rows, you must include the reference to the child column in an aggregate function. For example, Sum(Child.Price) would return the sum of the column named Price in the child table.

If a table has more than one child, the syntax is: Child(RelationName). For example, if a table has two child tables named Customers and Orders, and the DataRelation object is named Customers2Orders, the reference would be as follows:



The following aggregate types are supported:

Sum (Sum)

Avg (Average)

Min (Minimum)

Max (Maximum)

Count (Count)

StDev (Statistical standard deviation)

Var (Statistical variance).

Aggregates are ordinarily performed along relationships. Create an aggregate expression by using one of the functions listed earlier and a child table column as detailed in PARENT/CHILD RELATION REFERENCING that was discussed earlier. For example:



An aggregate can also be performed on a single table. For example, to create a summary of figures in a column named "Price":



If you use a single table to create an aggregate, there would be no group-by functionality. Instead, all rows would display the same value in the column.

If a table has no rows, the aggregate functions will return a null reference (Nothing in Visual Basic).

Data types can always be determined by examining the DataType property of a column. You can also convert data types using the Convert function, shown in the following section.


The following functions are also supported:



Converts particular expression to a specified .NET Framework Type.


Convert(expression, type)


expression -- The expression to convert.

type -- The .NET Framework type to which the value will be converted.

Example: myDataColumn.Expression="Convert(total, 'System.Int32')"

All conversions are valid with the following exceptions: Boolean can be coerced to and from Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, String and itself only. Char can be coerced to and from Int32, UInt32, String, and itself only. DateTime can be coerced to and from String and itself only. TimeSpan can be coerced to and from String and itself only.



Gets the length of a string




expression -- The string to be evaluated.

Example: myDataColumn.Expression="Len(ItemName)"



Checks an expression and either returns the checked expression or a replacement value.


ISNULL(expression, replacementvalue)


expression -- The expression to check.

replacementvalue -- If expression is a null reference (Nothing in Visual Basic), replacementvalue is returned.

Example: myDataColumn.Expression="IsNull(price, -1)"



Gets one of two values depending on the result of a logical expression.


IIF(expr, truepart, falsepart)


expr -- The expression to evaluate.

truepart -- The value to return if the expression is true.

falsepart -- The value to return if the expression is false.

Example: myDataColumn.Expression = "IIF(total>1000, 'expensive', 'dear')



Removes all leading and trailing blank characters like \r, \n, \t, ' '




expression -- The expression to trim.



Gets a sub-string of a specified length, starting at a specified point in the string.


SUBSTRING(expression, start, length)


expression -- The source string for the substring.

start -- Integer that specifies where the substring starts.

length -- Integer that specifies the length of the substring.

Example: myDataColumn.Expression = "SUBSTRING(phone, 7, 8)"


You can reset the Expression property by assigning it a null value or empty string. If a default value is set on the expression column, all previously filled rows are assigned the default value after the Expression property is reset.

The following example creates three coumns in a DataTable. The second and third columns contain expressions; the second calculates tax using a variable tax rate, and the third adds the result of the calculation to the value of the first column. The resulting table is displayed in a DataGrid control.

No code example is currently available or this language may not be supported.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

.NET Framework

Supported in: 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0