The Visual Basic Team : Converting SQL to LINQ

Converting SQL to LINQ, Part 10: Like (Bill Horst)

VBTeam — Thu, 08 May 2008 02:54:00 GMT

This post assumes you’ve read my previous Converting SQL to LINQ posts.

I haven’t had much in the way of specific requests for more LINQ posts, so I’d still welcome any suggestions that people want to offer. I did get one request about how to mimic the LIKE keyword functionality in VB LINQ.

In SQL, the LIKE keyword compares a string field against a pattern and returns a Boolean value representing whether the string matches the pattern. For example, if I wanted to select every customer in the 206 area code, I could use this SQL query:

SQL

SELECT *

FROM CustomerTable

WHERE Phone LIKE ‘206*’

The LIKE expression can include certain wildcard characters, which may differ from system to system. In the above example, * matches any string, so ‘206*’ represents any string that begins with 206.

VB happens to include a Like operator, so this is an easy conversion to make. The LINQ version of this above SQL expression is specified below:

From Contact In CustomerTable _

Where Contact.Phone Like “206*”

The VB Like keyword has the following wildcards:

? Matches any single character

* Matches zero or more characters

# Matches any single digit

[ charlist ] Matches any single character in the charlist

[! charlist ] Matches any single character not in the charlist

More extensive documentation of the Like operator can be found here.

- Bill Horst, VB IDE Test

Converting SQL to LINQ, Part 9: Full Outer Join (Bill Horst)

VBTeam — Tue, 12 Feb 2008 19:47:00 GMT

This post assumes you’ve read the previous posts in this series. It makes the same assumptions as Part 8, and I will pick up where I left off, covering Full Outer Join. Once again, I recognize this isn’t an ideal situation, so if you’d like to see better support of Full Outer Join in a future VB release, you can file a suggestion from our product feedback site.

A Full Outer Join is basically like the union of the results of a Left Outer Join and Right Outer Join. Records are joined together based on common fields, and all records with no match are also displayed, whether in the “left” or “right” table.

SQL

SELECT Contact.ContactName, Shipment.OrderDate

FROM CustomerTable Contact

FULL OUTER JOIN OrderTable Shipment

ON Contact.CustomerID = Shipment.CustomerID

Using the same data as my last post, this query would give me results like the following:

Results:

ContactName OrderDate

John Doe NULL

Bill Horst 3/25/1982

Bill Horst 3/13/2005

Jane Doe 9/29/2007

NULL 1/31/2008

Like Left and Right Join, Full Outer Join is not supported directly with LINQ, but you can write a query to produce the same results. Currently, the simplest way to do this is to concatenate three subqueries together.

The first query provides the results where the “right” table has a null value.

From Contact In CustomerTable _

Group Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into HaveMatch = Any() _

Where Not HaveMatch _

Select Contact.ContactName, OrderDate = NothingDate

Results:

{ContactName = "John Doe", OrderDate = Nothing}

The second query provides the results of an Inner Join.

From Contact In CustomerTable _

Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Select Contact.ContactName, Shipment.OrderDate

Results:

{ContactName = "Bill Horst", OrderDate = #3/25/1982#}

{ContactName = "Bill Horst", OrderDate = #3/13/2005#}

{ContactName = "Jane Doe", OrderDate = #9/29/2007#}

The third query provides the results where the “left” table has a null value.

From Shipment In OrderTable _

Group Join Contact In CustomerTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into HaveMatch = Any() _

Where Not HaveMatch _

Select ContactName = NothingString, Shipment.OrderDate

Results:

{ContactName = Nothing, OrderDate = #1/31/2008#}

When the results are put together, we get a full outer join.

(From Contact In CustomerTable _

Group Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into HaveMatch = Any() _

Where Not HaveMatch _

Select Contact.ContactName, OrderDate = NothingDate) _

.Concat(From Contact In CustomerTable _

Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Select Contact.ContactName, Shipment.OrderDate) _

.Concat(From Shipment In OrderTable _

Group Join Contact In CustomerTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into HaveMatch = Any() _

Where Not HaveMatch _

Select ContactName = NothingString, Shipment.OrderDate)

Results:

{ContactName = "John Doe", OrderDate = Nothing}

{ContactName = "Bill Horst", OrderDate = #3/25/1982#}

{ContactName = "Bill Horst", OrderDate = #3/13/2005#}

{ContactName = "Jane Doe", OrderDate = #9/29/2007#}

{ContactName = Nothing, OrderDate = #1/31/2008#}

Hopefully this is helpful to some. As noted above, I realize this is not an ideal way to implement a Full Outer Join. If you’d like to see support for a Full Outer Join with simple syntax in a future VB release, please file a suggestion from our product feedback site.

Also, I don't have much more material to post about LINQ, so if anyone would like to see a post on a different topic, I'm open to suggestions.

- Bill Horst, VB IDE Test

Converting SQL to LINQ, Part 8: Left/Right Outer Join (Bill Horst)

VBTeam — Thu, 31 Jan 2008 22:37:00 GMT

This post assumes you’ve read the previous posts in this series.

After my post on joins, I’ve had some questions about outer joins. As you can see in part 6, VB9 doesn’t have smooth support for Left or Right join. I showed how to get similar functionality with Group Join, but I’ve looked into the subject some more, and want to give everyone a more extensive explanation of how to get left, right, and full outer join results accurately with VB LINQ. Admittedly, these queries are very complex for a relatively simple concept, but unfortunately the VB team didn’t have the resources to implement these features in VB9. If this support is important to you, you can submit a suggestion to the Visual Studio team to have it included for a future release on our feedback page.

I’ll cover Left and Right Outer Join in this post and hopefully put up an additional post for Full Outer Join next week.

Assumptions

For my code examples, I’ll be using a slightly modified version of the classes I defined in my first post. In the below declarations, I’ve declared some nullable types on members which previously couldn’t have a value of Nothing (e.g. Integer -> Integer?).

Class Customer

Public CustomerID As Integer?

Public ContactName As String

Public Phone As String

Public Address As String

Public City As String

Public State As String

Public Zip As String

End Class

Class Order

Public OrderID As Integer?

Public CustomerID As Integer?

Public Cost As Single?

Public Phone As String

Public OrderDate As DateTime?

Public ShippingZip As String

Public ItemName As String

End Class

I’ve also declared CustomerTable and OrderTable variables as follows, to show some example results:

Dim CustomerTable As Customer() = { _

New Customer With {.ContactName = "Bill Horst", .CustomerID = 112}, _

New Customer With {.ContactName = "John Doe", .CustomerID = 354}, _

New Customer With {.ContactName = "Jane Doe", .CustomerID = 938}}

Dim OrderTable As Order() = { _

New Order With {.OrderDate = #3/25/1982#, .CustomerID = 112}, _

New Order With {.OrderDate = #3/13/2005#, .CustomerID = 112}, _

New Order With {.OrderDate = #9/29/2007#, .CustomerID = 938}, _

New Order With {.OrderDate = #1/31/2008#, .CustomerID = 444}}

Left Join

A SQL LEFT OUTER JOIN is like a standard Inner Join, but it returns results in the “Left Table” even if there is no matching result in the “Right Table”. For example:

SQL

SELECT Contact.ContactName, Shipment.OrderDate

FROM CustomerTable Contact

LEFT OUTER JOIN OrderTable Shipment

ON Contact.CustomerID = Shipment.CustomerID

Assuming the above data in CustomerTable and OrderTable, this query would give me results like the following:

Results:

ContactName OrderDate

Bill Horst 3/25/1982

Bill Horst 3/13/2005

John Doe NULL

Jane Doe 9/29/2007

If I want to re-create this query in VB code, I can start by setting up a Group Join between CustomerTable and OrderTable. I don’t want to calculate any aggregate values, so I’ll use the Group keyword to provide an entry for each member of CustomerTable with a corresponding array of entries from OrderTable.

From Contact In CustomerTable _

Group Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into RightTableResults = Group

Results:

{Contact={Customer}, RightTableResults = {Grouping}}

{Contact={Customer}, RightTableResults = {Order[]}}

{Contact={Customer}, RightTableResults = {Grouping}}

However, I don’t want a series of arrays, so I’ll add a From clause to cross-join each Contact with the individual members of the corresponding array.

From Contact In CustomerTable _

Group Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into RightTableResults = Group _

From Shipment In RightTableResults.DefaultIfEmpty

Results:

{Contact = {Customer}, RightTableResults = {Grouping}, Shipment = {Order}}

{Contact = {Customer}, RightTableResults = {Order[]}, Shipment = Nothing}

{Contact = {Customer}, RightTableResults = {Grouping}, Shipment = {Order}}

Now I want to Select only the fields in which I’m I’m interested– Contact.ContactName and Shipment.OrderDate:

From Contact In CustomerTable _

Group Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into RightTableResults = Group _

From Shipment In RightTableResults.DefaultIfEmpty _

Select Contact.ContactName, _

Shipment.OrderDate

This code still has a problem, though – when I get to the entry where Shipment = Nothing, the Select statement will throw a NullReferenceException. So, I need to do something to handle this case. There are several ways you could work around this, such as defining your own method, but the way I’ve chosen is with some ternary operator calls:

From Contact In CustomerTable _

Group Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into RightTableResults = Group _

From Shipment In RightTableResults.DefaultIfEmpty _

Select Contact.ContactName, _

OrderDate = _

If(Shipment Is Nothing, Nothing, _

If(Shipment Is Nothing, New Order, Shipment).OrderDate)

Results:

{ContactName = "Bill Horst", OrderDate = {DateTime}}

{ContactName = "John Doe", OrderDate = Nothing}

{ContactName = "Jane Doe", OrderDate = {DateTime}}

Clearly, this code is quite complicated, but if will accomplish the equivalent of a LEFT OUTER JOIN without any Aggregate functions. As you develop a deeper familiarity with LINQ, you may be able to find simpler ways to convert your specific OUTER JOIN queries.

For completeness, here is the corresponding Right Outer Join:

Dim RightJoin = _

From Shipment In OrderTable _

Group Join Contact In CustomerTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into RightTableResults = Group _

From Contact In RightTableResults.DefaultIfEmpty _

Select ContactName = _

If(Contact Is Nothing, _

Nothing, _

If(Contact Is Nothing, _

New Customer, _

Contact).ContactName), _

Shipment.OrderDate

Please comment with additional topic ideas for this series. Next time I plan to cover Full Outer Join.

- Bill Horst, VB IDE Test

Converting SQL to LINQ, Part 7: UNION, TOP, Subqueries (Bill Horst)

VBTeam — Tue, 08 Jan 2008 22:31:00 GMT

This post assumes you’ve read the previous posts in this series:

Converting SQL to LINQ, Part 1: The Basics

Converting SQL to LINQ, Part 2: FROM and SELECT

Converting SQL to LINQ, Part 3: DISTINCT, WHERE, ORDER BY and Operators

Converting SQL to LINQ, Part 4: Functions

Converting SQL to LINQ, Part 5: GROUP BY and HAVING

Converting SQL to LINQ, Part 6: Joins

This post will discuss UNION, TOP and Subqueries. Next week, I plan to cover LEFT, RIGHT and FULL OUTER JOIN more fully. If there are additional topics you’d like to see discussed related to converting SQL to LINQ, please add a comment to this post.

UNION

In SQL, a UNION clause joins the results of two SELECT queries into one set of data. With VB LINQ, the Union method can be called on a query, and passed a second query to produce the same result. The Intersect method is also available, and returns the common elements of the two query results. The Except method returns all the results from the first query that don’t appear as results from the second query.

SQL

SELECT CustomerID ID FROM CustomerTable

UNION

SELECT OrderID ID From OrderTable

(From Contact In CustomerTable _

Select ID = Contact.CustomerID).Union(From Shipment In OrderTable _

Select ID = Shipment.OrderID)

TOP

The SQL TOP operator returns the first n results of a query. A Take clause can accomplish the same thing in a VB LINQ expression. Take is described in more detail below, along with some related clauses.

SQL

SELECT TOP 10 * FROM CustomerTable ORDER BY CustomerID

From Contact In CustomerTable Order By Contact.CustomerID Take 10

Take/Skip/While

The Take clause is applied to the results of the clause that precedes it, and specifies a number of results to “take”, or return. All additional results are disregarded.

The Skip clause specifies a number of results to be ignored at the “top” of a query result. The results of the preceding clause are passed in, and all but the first n results are returned.

The Take While clause specifies a condition, and takes results from the start of a query result until the condition evaluates to false.

The Skip While clause specifies a condition, and skips results from the start of a query result until the condition evaluates to be false.

To give concrete examples, the following queries returns the following result:

Dim digits = New Integer() {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

Dim AllDigits = From int In digits

Results:

0 3 6 9

1 4 7

2 5 8

SKIP

Dim SkipFirstTwo = From int In digits Skip 2

Results:

2 5 8

3 6 9

4 7

TAKE

Dim TakeFirstTwo = From int In digits Take 2

Results:

SKIP and TAKE together

Dim SkipTwoTakeFive = From int In digits Skip 2 Take 5

Results:

2 5

3 6

SKIP WHILE

Dim SkipUntilFour = From int In digits Skip While int Mod 5 <> 4

Results:

4 7

5 8

6 9

TAKE WHILE

Dim TakeUntilThree = From int In digits _

Take While int = 0 OrElse int Mod 3 <> 0

Results:

0 2

Subqueries

SQL SELECT statements can also have subqueries, where a query uses the results of another query. A VB LINQ expression can contain a subquery anywhere an expression is allowed, and like a SQL subquery, you will want to use parentheses to avoid ambiguities in the syntax.

SQL

SELECT OrderID, OrderDate

FROM OrderTable

WHERE CustomerID = (SELECT CustomerID

FROM CustomerTable

WHERE City = “Seattle”)

From Shipment In OrderTable _

Where (From Contact In CustomerTable _

Where Contact.City = “Seattle” _

Select Contact.CustomerID).Contains(Shipment.CustomerID) _

Select Shipment.OrderID, Shipment.OrderDate

Also note that because a query expression returns an IEnumerable, you can also query over query results:

Dim SeattleOrders = From Contact In CustomerTable _

Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Where Contact.City = “Seattle”

Dim FilteredOrders = From Shipment In SeattleOrders _

Select Shipment.OrderID, Shipment.OrderDate

I’m interested to hear your topic ideas. Next time, I’ll talk more about LEFT/RIGHT/FULL OUTER JOIN.

- Bill Horst, VB IDE Test

Converting SQL to LINQ, Part 6: Joins (Bill Horst)

VBTeam — Mon, 31 Dec 2007 21:45:00 GMT

This post assumes you’ve read the previous posts in this series:

Converting SQL to LINQ, Part 1: The Basics

Converting SQL to LINQ, Part 2: FROM and SELECT

Converting SQL to LINQ, Part 3: DISTINCT, WHERE, ORDER BY and Operators

Converting SQL to LINQ, Part 4: Functions

Converting SQL to LINQ, Part 5: GROUP BY and HAVING

This post will discuss Cross Join, Inner Join, Natural Join and Outer (Left/Right) Joins.

JOIN

It’s very common to query over more than one set of data (such as a table) in the same SQL SELECT statement. Bringing together the information in multiple tables is called a join, and there are several kinds of joins in both SQL and LINQ.

Cross Join

The simplest join is a Cross Join, or Cartesian Join, which is a many-to-many join between two sets of data. Each record in one set of data is joined to each record in another set. In a SQL SELECT statement, this is done by specifying more than one table in a FROM clause. In a VB LINQ expression, the same is true, as shown below.

SQL

SELECT CustomerTable.Name, OrderTable.OrderDate

FROM CustomerTable, OrderTable

From Contact In CustomerTable, Shipment In OrderTable _

Select Contact.Name, Shipment.OrderDate

Inner Join

An Inner Join is a one-to-one join, where records in one set of data are matched up with records in another set of data based on certain common fields. In a SQL SELECT statement, the second set of data is specified in an INNER JOIN clause, and the equalities used to join them are specified in an ON clause. Similarly, the second set of data in a VB LINQ Join is specified in a Join clause, and an On clause is used to specify which field to match up with the Equals operator.

SQL

SELECT Contact.Name, Shipment.OrderID

FROM CustomerTable Contact

INNER JOIN OrderTable Shipment

ON Contact.CustomerID = Shipment.CustomerID

AND Contact.Zip = Shipment.ShippingZip

From Contact In CustomerTable

Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

And Contact.Zip Equals Shipment.ShippingZip _

Select Contact.Name, Shipment.OrderID

The above example is an Equi-Join, meaning an equality operator is used to join information between the tables. This is the only operator allowed in the On clause, so to emulate any other join operators (such as less-than), you will need to use a Cross Join filtered with a Where clause.

SQL

SELECT Contact.Name, Shipment.OrderID

FROM CustomerTable Contact

INNER JOIN OrderTable Shipment

ON Contact.CustomerID < Shipment.CustomerID

From Contact In CustomerTable, Shipment In OrderTable _

Where Contact.CustomerID < Shipment.CustomerID

Select Contact.Name, Shipment.OrderID

Natural Join

A Natural Join is a one-to-one join where records in one set of data are matched up with records in another set of data based on all common fields (determined by matching names). In a SQL SELECT statement, the second set of data can be specified in a NATURAL JOIN clause, and the equalities used to join the tables are implicit. There is no direct equivalent to a natural join in VB LINQ expressions, so the best way to emulate it is to create an inner join and specify all common field equalities in the On clause manually. This is more verbose than the SQL version, but should be pretty straightforward.

SQL

SELECT * FROM CustomerTable

NATURAL JOIN OrderTable

From Contact In CustomerTable _

Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _
And Contact.Phone Equals Shipment.Phone

Outer (Left/Right) Join

An Outer Join (also known as a Left Join or Right Join) is a one-to-many join, where each record in one set of data can be matched up with multiple records in another set of data, based on common fields. In a SQL SELECT statement, the second set of data is specified in a LEFT JOIN or RIGHT JOIN clause, and the equalities used to join them are specified in an ON clause. In a LEFT JOIN, every record in the first (left) set of data is joined with all records in the second set of data that match it based on the join expressions. Every record in this first set of data will appear in the result, whether or not it matches anything in the second set. This is reversed in a RIGHT JOIN, where everything in the second (right) set of data appears and is matched to everything possible in the first set.

The closest VB LINQ construct to an Outer Join would be a Group Join. A Group Join clause specifies a second set of data, and provides the equality expressions in the On clause, much like a Join (Inner Join), described above. There is also an Into clause, which can be used to specify aggregates to calculate over each group, much like in a Group Join clause above.

Similar to a SQL LEFT JOIN, each member of the first set of data is matched with everything that matches it in the second set of data. Again, if there is no match for an item in the first set of data, it will still appear in the results.

SQL

SELECT CustomerTable.Name, SUM(OrderTable.Cost) Sum

FROM CustomerTable

LEFT JOIN OrderTable

ON CustomerTable.CustomerID = OrderTable.CustomerID

GROUP BY CustomerTable.Name

From Contact In CustomerTable _

Group Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into Sum(Shipment.Cost) _

Select Contact.Name, Sum

The best way to convert a RIGHT JOIN is to use this Group Join clause with the tables reversed (put the last one first).

It may be that there are times an Outer Join will be needed without aggregate functions. Using a Group keyword, as shown below, causes an array to be returned with the results in a particular group. This is probably the closest VB LINQ equivalent to an Outer Join without aggregate functions.

SQL

SELECT *

FROM CustomerTable Contact

LEFT JOIN OrderTable Shipment

ON Contact.CustomerID = Shipment.CustomerID

From Contact In CustomerTable _

Group Join Shipment In OrderTable _

On Contact.CustomerID Equals Shipment.CustomerID _

Into Group

These Group Join examples may not cover all the LEFT JOIN and RIGHT JOIN scenarios you’ll encounter, but hopefully they will give you the understanding necessary to create a LINQ query that matches your existing SQL query.

Next week, I plan to cover a “grab bag” of topics, including UNION, TOP and Sub-queries.

If there are any additional SQL SELECT constructs you’d like to see in LINQ, please add a comment to this post about it.

- Bill Horst, VB IDE Test

Converting SQL to LINQ, Part 5: GROUP BY and HAVING (Bill Horst)

VBTeam — Wed, 19 Dec 2007 03:05:00 GMT

This post assumes you’ve read the previous posts in this series:

Converting SQL to LINQ, Part 1: The Basics

Converting SQL to LINQ, Part 2: FROM and SELECT

Converting SQL to LINQ, Part 3: DISTINCT, WHERE, ORDER BY and Operators

Converting SQL to LINQ, Part 4: Functions

This post will discuss the GROUP BY and HAVING clauses.

GROUP BY

A SQL GROUP BY clause allows you to group records by particular fields, so the entire group can be dealt with at once. A LINQ statement can have a Group By clause as well, but with different syntax. An informal (and incomplete) syntax expression could be:

VB Group By

Group [{optional list of fields}] By {list of fields} _

Into {list of aggregate expressions}

In this syntax, all the listed expressions can have aliases, and must if an identifier cannot be inferred. Essentially, the clause is “Group By” followed by a list of fields by which to group the records, then “Into” followed by a list of aggregate expressions to calculate. For example, the following query calculates the total and average cost of shipments to each zip code:

From Shipment In OrderTable _

Group By Shipment.ShippingZip _

Into Total = Sum(Shipment.Cost), Average(Shipment.Cost)

This query expression returns three values, ShippingZip, Total and Average, for each zip code represented in the data.

Optionally, a list of fields can be provided between the “Group” and “By” keywords to narrow down the information included to specific fields. This could be thought of as a built-in Select clause prior to the Into clause:

From Shipment In OrderTable _

Group OrderCost = Shipment.Cost By Shipment.ShippingZip _

Into Total = Sum(OrderCost), Average(OrderCost)

In addition to aggregate expressions, the Into clause can also contain the keyword “Group”, which causes the individual records to be included for each group, as an array member. For each pairing of zip code and order date represented in the data, the following query expression returns two values, Zip and OrderDate, plus an array representing all the records in the group.

From Shipment In OrderTable _

Group By Zip = Shipment.ShippingZip, Shipment.OrderDate _

Into Group

When there are no fields specified between “Group” and “Order By”, as above, all fields are included in the records in the Group array. Including specific fields narrows the information to the specified fields, as though the records were filtered through a Select clause. For each zip code and order date pairing represented in the data, the following query expression returns Zip and OrderDate values, plus an array of ID and Cost fields for each record in the group.

From Shipment In OrderTable _

Group ID = Shipment.OrderID, Shipment.Cost By _

Zip = Shipment.ShippingZip, Shipment.OrderDate _

Into Group

I’ve given a lot of examples because the syntax is fairly complex, but now we start to see how to convert various SQL statements with GROUP BY clauses to VB. Below is an example:

SQL

SELECT OrderDate Date_Of_Order, SUM(Cost) Daily_Total

FROM OrderTable

GROUP BY Date_Of_Order

From Shipment In OrderTable _

Group By Date_Of_Order = Shipment.OrderDate _

Into Daily_Total = Sum(Shipment.Cost)

Having

Having is another SQL clause which can specify conditions for a group’s inclusion in the query results. VB has no corresponding clause, so the best way to re-create this with VB LINQ is to use a Where clause after a Group By clause, as shown below.

SQL

SELECT OrderDate Date_Of_Order, SUM(Cost) Total_Cost

FROM OrderTable

GROUP BY Date_Of_Order

HAVING SUM(Cost) > 1000

From Shipment In OrderTable _

Group By Date_Of_Order = Shipment.OrderDate _

Into Total_Cost = Sum(Shipment.Cost)

Where Total_Cost > 1000

In my next post, I plan to cover various kinds of joins.

- Bill Horst, VB IDE Test

Converting SQL to LINQ, Part 4: Functions (Bill Horst)

VBTeam — Wed, 12 Dec 2007 20:45:00 GMT

This post assumes you’ve read the previous posts in this series:

Converting SQL to LINQ, Part 1: The Basics

Converting SQL to LINQ, Part 2: FROM and SELECT

Converting SQL to LINQ, Part 3: DISTINCT, WHERE, ORDER BY and Operators

This post will discuss scalar and aggregate functions.

Functions

SQL SELECT clauses often involve functions, which can be scalar or aggregate. An aggregate function is applied to a field over all the selected records, while a scalar function is called with individual values, one record at a time. It is possible to re-create both kinds of functions with VB LINQ expressions, but in very different ways.

Scalar Functions

Scalar functions are called on each record with whatever parameters are specified. They can appear various places in a SQL query, such as in the SELECT clause. The Scalar Functions available differ from system to system, but usually, there will be an analogous VB method that can be used. If using a Scalar Function in a LINQ Select clause, you will probably need to specify an alias as well (FirstThreeLetters, CurrentTime).

SQL

SELECT LEFT(ItemName, 3) FirstThreeLetters, NOW() CurrentTime

FROM OrderTable

From Shipment In OrderTable _

Select FirstThreeLetters = Left(Shipment.ItemName, 3), CurrentTime = Now

In the above case, Left and Now are methods already built into VB, defined in Microsoft.VisualBasic.dll. This will likely be the case for most common scalar functions you will find in SQL statements. Even if the function you wish to call does not exist in VB already, you can define your own methods, too. However, user-defined methods cannot be used in a Database query, as they will throw an exception at runtime. In the below example, MyFunction is a user-defined function called from the Select clause.

From Shipment In OrderTable _

Select MyFunction(Shipment.Cost, Shipment.ShippingZip)

Aggregate Functions

Aggregate functions are called on certain fields over an entire set of records, and return one value. In a SQL statement, they can appear in the SELECT clause. With VB LINQ, this concept appears a bit differently.

A VB LINQ expression usually begins with a From clause. However, they can also begin with an Aggregate clause. The Aggregate clause has the same syntax as a From clause, except that it starts with a different keyword. If a query starts with an Aggregate clause, it must end with an Into clause. An Into clause is a comma-delimited list of Aggregate function calls, with aliases that can accompany them. The below example shows a SQL SELECT statement that uses Aggregate functions, and an equivalent VB LINQ expression.

SQL

SELECT SUM(Cost) TotalCost, COUNT(*)

FROM OrderTable

WHERE OrderDate > “Sept-29-2007”

Aggregate Shipment In OrderTable _

Where Shipment.OrderDate > #9/29/2007# _

Into TotalCost = Sum(Shipment.Cost), Count()

Next week, I will discuss GROUP BY and HAVING.

Converting SQL to LINQ, Part 3: DISTINCT, WHERE, ORDER BY and Operators (Bill Horst)

VBTeam — Tue, 04 Dec 2007 21:31:00 GMT

This post assumes you’ve read the previous posts in this series:

Converting SQL to LINQ, Part 1: The Basics

Converting SQL to LINQ, Part 2: FROM and SELECT

Continuing with specific query clauses, I will cover topics related to DISTINCT, WHERE and ORDER BY.

DISTINCT

SQL SELECT statements can include the DISTINCT specifier, which causes all duplicate records in the query result to be removed. In a LINQ expression, Distinct is its own individual clause, rather than a specifier on the Select clause. This means that Distinct can appear between any two other clauses. The Distinct clause takes whatever result is returned by the preceding clause (Select, in the case below) and returns a filtered result with duplicates removed. To two code examples below accomplish the same results:

SQL

SELECT DISTINCT Name, Address

FROM CustomerTable

From Contact In CustomerTable _

Select Contact.Name, Contact.Address _

Distinct

WHERE

Much like a SQL query, a LINQ expression allows you to add a Where clause to filter the results based on a certain condition. You can use any valid VB Boolean expression.

SQL

SELECT * FROM CustomerTable

WHERE State = “WA”

From Contact In CustomerTable _

Where Contact.State = “WA”

Operators

SQL WHERE clauses can often include other operators like AND. There will usually be a similar operator in VB that can be used in the Where clause expression to accomplish the same result.

SQL

SELECT * FROM CustomerTable

WHERE City = “Seattle” AND Zip = “98122”

From Contact In CustomerTable _

Where Contact.City = “Seattle” And Contact.Zip = “98122”

Even if there is no equivalent VB operator, it should be possible to represent nearly any SQL WHERE expression as a VB expression. BETWEEN is an example of a SQL keyword that doesn’t have an analogous VB keyword, but which can be easily represented in VB.

SQL

SELECT * FROM OrderTable

WHERE OrderDate BETWEEN ‘Sept-22-2007’ AND ‘Sept-29-2007’

From Shipment In OrderTable _

Where (Shipment.OrderDate > #9/22/2007#) _

And (Shipment.OrderDate < #9/29/2007#)

ORDER BY

The SQL ORDER BY clause can also be represented in a LINQ expression. A LINQ Order By clause allows for a comma-delimited list of expressions to specify how results should be sorted. Any valid VB expression can be used, so these expressions don’t necessarily have to be the names of field that were selected.

SQL

SELECT * FROM CustomerTable

ORDER BY Phone

From Contact In CustomerTable _

Order By Contact.Phone

ASC/DESC

A SQL ORDER BY clause can also include ASC and DESC keywords, to specify that the sort should be in ascending or descending order, respectively. VB uses Ascending and Descending keywords for the same purpose, with the same syntax. If neither specifier is present, ascending order is the default.

SQL

SELECT * FROM CustomerTable

ORDER BY Phone ASC, Name DESC

From Contact In CustomerTable _

Order By Contact.Phone Ascending, Contact.Name Descending

With this and my two previous posts, it should be possible to convert basic SQL queries to VB LINQ code. Next week, I’ll talk about Functions, both Scalar and Aggregate.

- Bill Horst, VB IDE Test

Converting SQL to LINQ, Part 2: FROM and SELECT (Bill Horst)

VBTeam — Wed, 28 Nov 2007 21:37:00 GMT

This post assumes you’ve read Converting SQL to LINQ, Part 1: The Basics.

I’ve made the following name changes since the last post, which I hope will make the code examples clearer:

· Customers -> CustomerTable

· Orders -> OrderTable

· cust -> Contact

· CustomerName -> ContactName

· ID -> ContactID

Since I plan to do a handful more of these posts, I welcome any feedback or suggestions so I can make these as clear and useful as possible.

Continuing on to specific clauses, we’ll start with the most fundamental, FROM and SELECT.

FROM

A SQL SELECT statement always begins with a SELECT Clause, followed by a FROM Clause. A VB query expression always begins with a From Clause or Aggregate Clause (Aggregate will be discussed later). A basic SQL FROM clause specifies a table over which to query, and similarly, a LINQ From Clause specifies an object over which to query (CustomerTable). This object could represent “In-Memory” data, a SQL data table, or XML information. My examples use the “In-Memory” case, since it allows the simplest code. In addition to this data object, the VB From clause always includes an identifier for the current “row” (Contact), which basically functions as an alias.

If all columns are selected in the SQL statement (*), no Select clause is required for the VB statement. The From Clause returns all the members by default.

SQL

SELECT *

FROM CustomerTable

From Contact In CustomerTable

Alias in FROM

SQL allows you to specify an alias for a table in the FROM Clause, so that all references to columns in that table will be qualified with that alias (Contact). As mentioned above, the identifier specified in the LINQ From Clause serves essentially the same purpose.

SQL

SELECT Contact.CustomerID, Contact.Phone

FROM CustomerTable Contact

From Contact In CustomerTable

Select Contact.CustomerID, Contact.Phone

SELECT

SQL SELECT statements start with a list of values to select from the records available (Name, CustomerID). Similarly, LINQ also allows you to select certain members, and will return an object with those members, having an anonymous type. The members specified don’t necessarily need to be part of the object in the From clause, but can be any valid VB expression (e.g. 3 + 4). If the name for the member cannot be inferred, an alias must be specified (see “Alias in SELECT” below).

SQL

SELECT Name, CustomerID

FROM CustomerTable

From Contact In CustomerTable

Select Contact.Name, Contact.CustomerID

Alias in SELECT

SQL also allows members in the SELECT clause to have an alias (ContactName, ContactID), by which they are referred to in the rest of the query. LINQ also allows you to specify the name of a member. This is how the member will be referenced after that Select clause in the query, and anywhere the result of the query is specified elsewhere in code.

SQL

SELECT Name ContactName, CustomerID ContactID

FROM CustomerTable

From Contact In CustomerTable

Select ContactName = Contact.Name, ContactID = Contact.CustomerID

Next week, I plan to cover DISTINCT, WHERE, ORDER BY, and Operators

- Bill Horst, VB IDE Test

Converting SQL to LINQ, Part 1: The Basics (Bill Horst)

VBTeam — Mon, 19 Nov 2007 22:26:00 GMT

As you may already know, VB LINQ statements enable SQL-like syntax for queries in the VB language. LINQ syntax doesn't match SQL syntax exactly, so if you are already working with SQL or familiar with SQL queries, you may find yourself wanting to convert an existing SQL query to LINQ.

This will be the first in a series of posts about converting SQL to LINQ. In this post, I want to establish a basic understanding of how SQL differs from LINQ, and then get into specific language constructs next time.

Assumptions

The SQL code examples I'll be using assume a table called Customers and a table called Orders. The VB code examples assume some object named Customers with type IEnumerable(Of Customer) and another object named Orders with type IEnumerable(Of Order). I'll also use two classes, Customer and Order, which are defined below.

Class Customer

Public CustomerID As Integer

Public Name As String

Public Phone As String

Public Address As String

Public City As String

Public State As String

Public Zip As String

End Class

Class Order

Public OrderID As Integer

Public CustomerID As Integer

Public Cost As Single

Public Phone As String

Public OrderDate As DateTime

Public ShippingZip As String

Public ItemName As String

End Class

Basic Syntax

LINQ supports SQL SELECT statements, but not other types of SQL statements, such as CREATE, INSERT, UPDATE and DELETE. The basic syntax for a SQL SELECT statement can be considered as a series of "clauses", where the first clause is a SELECT clause.

sqlSelectClause [ sqlClause1 [ sqlClause2 [ ... ] ] ]

SQL syntax can differe a bit among different versions, but here's an example for instance:

SQL

SELECT Name CustomerName, CustomerID ID

FROM Customers

ORDER BY ID

The basic syntax for a VB LINQ expression is also a series of "clauses", of which the first is a From Clause (or Aggregate Clause, but we'll get to that later).

linqFromClause [ linqClause1 [ linqClause2 [ ... ] ] ]

For instance:

From cust In Customers _

Select CustomerName = cust.Name, ID = cust.CustomerID _

Order By ID

I say "VB LINQ expression" above because LINQ Queries are not full statements. Though a SQL statement may appear on its own, LINQ Queries are syntactically the same as an expression like 3 * 4. This isn't a whole statement, so something must be "done" with it. A LINQ Query might appear in VB code like this:

Dim SortedCustomers = From cust In Customers _

Select CustomerName = cust.Name, ID = cust.CustomerID _

Order By ID

Conceptually, each clause in a LINQ query is called on an object with type IEnumerable(Of T) and returns another IEnumerable(Of T) where T in the return type is not necessarily the same as the initial type. Query clauses are generally analogous to SQL clauses (e.g. SELECT, ORDER BY), so you can usually convert your SQL query to LINQ in a clause-by-clause fashion. In the above examples, the clauses appear in a slightly different order and have different syntax, but as you can see, they are quite similar.

Also notice that SQL syntax usually allows line breaks to be made between clauses. In VB this requires an underscore at the end of each line to show that the expression is continued on the next line.

This is a broad explanation, but I'll get into the specifics next week. My intention is to include the following installments:

FROM and SELECT
DISTINCT, WHERE, ORDER BY, Operators
Functions (Scalar and Aggregate)
GROUP By and HAVING
Joins
UNION, TOP and Subqueries

- Bill Horst, VB IDE Test