NGWS SDK Documentation  

This is preliminary documentation and subject to change.
To comment on this topic, please send us email at ngwssdk@microsoft.com. Thanks!

DataColumn.Expression

Gets or sets the expresssion used to either filter rows, calculate the column's value, or create an aggregate column.

[Visual Basic]
Public Property Expression As String
[C#]
public string Expression {get; set;}
[C++]
public: __property String* get_Expression();
public: __property void set_Expression(String*);
[JScript]
public function get Expression() : String;
public function set Expression(String);

Property Value

An expression to calculate the column's value, or create an aggregate column.

Exceptions

Exception Type Condition
ArgumentException The AutoIncrement or Unique property is set to true.

Remarks

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 given region. Since 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 below:

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 entire set of rows in the DataTable. A simple example is to count the number of rows returned in the set, which is the method you would use to count thenumber of transactions compelted by a particular salesperson, as shown in this Visual Basic code:

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

Finally, you can create row filters using the Expression. For example, to limit the displayed rows to only those people whose last name is "Smith," use the following expression:

DataSet1.Tables("Customers").Columns("LastName").Expression = "LastName = 'Smith'"

EXPRESSION SYNTAX

When creating 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:

"UnitPrice * Quantity"

When creating an expression for a filter, enclose strings with single quotes:

"LastName = 'Jones'"

The following characters are special characters and must escaped (explained below) if they are to be used in a column name:

\n (newline)

\t (tab)

\r (carriage return)

~

(

)

#

\

/

=

>

<

+

-

*

%

&

|

^

'

"

[

]

If a column name contains one of the above 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

User-defined values may be used within expressions to be compared against column values. String values should be enclosed within single quotes. 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#"

OPERATORS

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

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

When creating comparison expressions, the following operators are allowed:

<

>

<=

>=

<>

=

IN

LIKE

The following arithmetic operators are also supported in expressions:

+ (addition)

- (subtraction)

* (multiplication)

/ (division)

% (modulus)

STRING OPERATORS

To concatenate a string, use the + character. Whether string comparisons are case-sensitive or not is determined by the value of the DataSet class's CaseSensitive property. However, you can override that valuew with the DataTable class's CaseSensitive property.

WILDCARD CHARACTERS

Both the * and % can be used interchangeably for wildcards in a LIKE comparison. If the string in a LIKE clauses 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 (e.g. [[] or []]). A wildcards is allowed at the beginning and end of a pattern, or at the end of a pattern, or at the beginning of a pattern. For example:

"ItemName LIKE '*product*'"

"ItemName LIKE '*product'"

"ItemName LIKE 'product*'"

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

PARENT/CHILD RELATION REFERENCING

A column in a child table may be referenced in an expresion by prepending the column name with "Child." For example, "Child.Price" would reference 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 Employee and Titles, and the DataRelation objects are named "Publishers2Employee: and "Publishers2Titles," the reference would be:

Child(Publishers2Employee).fname

Child(Publishers2Titles).title

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."

AGGREGATES

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 usually performed along relationships. Create an aggregate expression by using one of the functions listed above and a child table column as detailed in PARENT/CHILD RELATION REFERENCING above. For example:

Avg(Child.Price)

Avg(Child(Orders2Details).Price)

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

Sum(Price)

Note   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 (in Visual Basic Nothing).

Data types can always be determined by examining the DataType property of a column. You can also convert data types using the Convert function. The syntax for the function is:

FUNCTIONS

The following functions are also supported:

CONVERT

Description Converts given expression to a specified Type.
Syntax Convert(expression, type)
Arguments expression type -- A NGWS type.FullName representing the type to which the value will be converted.

LEN

Description Returns the length of a string
Syntax LEN(expression)
Arguments expression -- The string to be evaluated.

ISNULL

Description Checks and expression and either returns a null or a replacement value.
Syntax ISNULL(expression, replacementvalue)
Arguments expression-- The expression to check.

replacementvalue-- If expression is null, replacementvalue is returned.

IIF

Description Returns one of two values depending on the result of a logical expression.
Syntax IIF(expr, truepart, falsepart)
Arguments 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 [Visual Basic]

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 System.WinForms.DataGrid control.

[Visual Basic]

Private Sub CalcColumns()
    Dim cPrice As DataColumn
    Dim cTax As DataColumn
    Dim cTotal As DataColumn
    Dim rate As Single
    rate = .0862
    dim t as DataTable = new DataTable 

    ' Create the first column.
    cPrice = New DataColumn
    With cPrice
        .DataType = System.Type.GetType("System.Currency")
        .ColumnName = "price"
        .DefaultValue = 50
    End With
    
    ' Create the second, calculated, column.
    cTax = New DataColumn
    With cTax
        .DataType = System.Type.GetType("System.Currency")
        .ColumnName = "tax"
        .Expression = "price * 0.0862"
    End With
    
   ' Create third column
    cTotal = New DataColumn
    With cTotal
        .DataType = System.Type.GetType("System.Currency")
        .ColumnName = "total"
        .Expression = "price + tax"
    End With

    ' Add columns to DataTable
    With t.Columns
        .Add(cPrice)
        .Add(cTax)
        .Add(cTotal)
    End With
   
    Dim r As DataRow
    r = t.NewRow
    t.Rows.Add(r)
    Dim dView As New DataView
    Set dView.Table = t
    dView.Open
    Set DataGrid1.DataSource = dView
    dataGrid1.PopulateColumns
End Sub

See Also

DataColumn Class | DataColumn Members | System.Data Namespace | RowFilter | Sort | TableSetting | Add