Is there a way to avoid pattern matching - f#

Question

I have SQL table for hierarchical data:
Maximum level of hierarchy is 5.
Lines #4 and #5 are children of line #1, for example.
I heed to have query expression to get child records by given one. Now I have this pattern matching:
let private queryForChild (db: dbml.MobileDataContext) id1 id2 id3 id4 id5 et =
match (id1, id2, id3, id4, id5) with
| _, "", "", "", "" -> query {
for rows in db.ItemType do
where (rows.Id1 = id1 && rows.Id2 <> "" && rows.Id3 = "" && rows.Id4 = "" && rows.Id5 = "" && rows.EntityType = et)
select rows
}
| _, _, "", "", "" -> query {
for rows in db.ItemType do
where (rows.Id1 = id1 && rows.Id2 = id2 && rows.Id3 <> "" && rows.Id4 = "" && rows.Id5 = "" && rows.EntityType = et)
select rows
}
| _, _, _, "", "" -> query {
for rows in db.ItemType do
where (rows.Id1 = id1 && rows.Id2 = id2 && rows.Id3 = id3 && rows.Id4 <> "" && rows.Id5 = "" && rows.EntityType = et)
select rows
}
| _, _, _, _, "" -> query {
for rows in db.ItemType do
where (rows.Id1 = id1 && rows.Id2 = id2 && rows.Id3 = id3 && rows.Id4 = id4 && rows.Id5 <> "" && rows.EntityType = et)
select rows
}
| _, _, _, _, _ -> query {
for rows in db.ItemType do
where (rows.Id1 = "-1")
select rows
}
I don't like it and wondering is there any way to rewrite it using boolean operators to avoid pattern matching ?

Answer 1

It is indeed not possible to use custom functions in a query computation, because the inside of the query computation gets quoted (as an F# Quotation) and then (ultimately) translated to SQL, and custom functions can't be thus translated.
However, unlike C#, F# does offer a code reuse facility within code quotations - it's called "splicing".
Consider an example:
let q = query { for x in listOfInts do yield x + 42 }
> q.Expression
val it : Expression = [1; 2; 3; ... ].Select(_arg1 => (_arg1 + 42))
Let's say I really don't like that + 42 over there, I'd like to abstract it away. Well, I can do it like this:
let add42 = <# fun i -> i + 42 #>
let q = query { for x in listOfInts do yield (%add42) x }
If we now examine q.Expression, we'll find that it's identical to the previous version:
> q.Expression
val it : Expression = [1; 2; 3; ... ].Select(_arg1 => (_arg1 + 42))
Here's what's happened here. add42 is a code quotation that contains a function that adds 42 to its argument. The %add42 expression "inserts" (aka "splices") that quotation in the middle of the larger quotation, resulting in an expression like this:
let q = query { for x in listOfInts do yield (fun i -> i + 42) x }
This expression then got simplified during translation from F# code quotation to System.Linq.Expressions.Expression, resulting in an expression identical to the first version.
The final piece to add: spliced quotations don't have to be "constant", they can be produced by functions too. These functions get evaluated during construction of the overall quotation, and their results then get spliced. For example, I could redefine the above code like this:
let add a = <# fun x -> x + a #>
let q2 = query { for x in list do yield (% add 42) x }
Now add is a function that takes 42 as argument and produces a code quotation that contains another function. Phew!
And now we can apply all that to your case: make yourself a function that will take idx as argument and produce a quotation of a function that, after splicing, would be applied to row.idx:
// NOTE: I'm not sure if this logic is correct. You'll have to verify it.
//
// For the i-th ID:
// * if all previous IDs are non-empty,
// but the i-th ID itself is empty,
// then the condition should check for i-th ID being non-empty.
// This means "query rows of i-th level".
// * if all previous IDs are non-empty,
// and the i-th ID itself is non-empty,
// then the condition should check for i-th ID being equal to
// This means "query rows of j-th level", where j > i
// * Otherwise, the condition should check for
// the i-th ID being empty.
// This means "query rows of j-th level", where j < i
let compare prevIds thisId =
if List.all ((<>) "") prevIds
then if thisId = ""
then <# fun id -> id <> "" #>
else <# fun id -> id = thisId #>
else <# fun id -> id = "" #>
let private queryForChild (db: dbml.MobileDataContext) id1 id2 id3 id4 id5 et =
query {
for rows in db.ItemType do
where (
(% compare [] id1) rows.Id1 &&
(% compare [id1] id2) rows.Id2 &&
(% compare [id1; id2] id3) rows.Id3
(% compare [id1; id2; id3] id4) rows.Id4
(% compare [id1; id2; id3; id4] id5) rows.Id5 &&
rows.EntityType = et )
select rows
}
Also note that the way you constructed your function, its behavior is not well defined for inputs with "holes" - i.e. id1="x", id2="", id3="y" - did you mean to query second or fourth level in this case? I would recommend a better data structure that excludes nonsensical inputs.

Answer 2

Perhaps, you can use something like this:
let equalOrNotEmpty a b =
match a with
| "" -> b <> ""
| a -> a = b
and usage would be
let private queryForChild (db:dbml.MobileDataContext) id1 id2 id3 id4 id5 =
query {
for rows in db.ItemType do
where (equalOrNotEmpty rows.Id1 id1
&& equalOrNotEmpty rows.Id2 id2
&& equalOrNotEmpty rows.Id3 id3
&& equalOrNotEmpty rows.Id4 id4
&& equalOrNotEmpty rows.Id5 id5
&& rows.EntityType = et)
select rows
}