F# casting type from query expression - f#

Question

I have a query expression of the form:
let result = query { for row in context.Table do
where (row.id = 111111)
select (row.col1,row.col2,row.col3) }
Result returns a value of type IQueryable<Nullable<float>*Nullable<float>*Nullable<float>>. I want it to return seq<float>*seq<float>*seq<float>.
I can try altering it like so:
let result :seq<float>*seq<float>*seq<float> = query { for row in context.Table do
where (row.id = 111111)
select (row.col1,row.col2,row.col3) }
|> Seq.cast
But I get:
Type mismatch. Expecting a IQueryable<Nullable<float> * Nullable<float> * Nullable<float>> -> seq<float> * seq<float> * seq<float>
but given a IQueryable<Nullable<float> * Nullable<float> * Nullable<float>> -> seq<'a>
The type 'seq<float> * seq<float> * seq<float>' does not match the type 'seq<'a>'
What am I doing wrong?
EDIT: Here's what I am trying to do, it sounds like my question may give me a usable answer but not the best way to do what I want. This code is ugly but works:
let col1 : seq<float> = query { for row in context.Table do
where (row.id = 111111)
select row.col1 }
|> Seq.cast
let col2 : seq<float> = query { for row in context.Table do
where (row.id = 111111)
select row.col2 }
|> Seq.cast
let model = MathNet.Numerics.Interpolation.CubicSpline.InterpolateAkima(col1,col2)
If I don't cast to float, InterpolateAkima won't work because it doesn't accept type Nullable. I don't want to have to do a query for each column on its own, though. My eventual goal is to have a function where I can pass in any value of row.id and get the model for col1,col2 then col1,col3 and so on.

Answer 1

There are two parts in this question:
Transforming a seq<a * b * c> into seq<a> * seq<b> * seq<c>: List.unzip3 and Array.unzip3 do exactly that.
Getting rid of the Nullable: it depends on what you want to happen when a value is null.
If you want to return 0 for null values:
let col1, col2, col3 =
query { for row in context.Table do
where (row.id = 111111)
let col1 = if row.col1.HasValue then row.col1.Value else 0.
let col2 = if row.col2.HasValue then row.col2.Value else 0.
let col3 = if row.col3.HasValue then row.col3.Value else 0.
select (col1, col2, col3) }
|> Array.ofSeq
|> Array.unzip3
If you want to ignore rows where there is a null:
let col1, col2, col3 =
query { for row in context.Table do
where (row.id = 111111 && row.col1.HasValue && row.col2.HasValue && row.col3.HasValue)
select (row.col1.Value, row.col2.Value, row.col3.Value) }
|> Array.ofSeq
|> Array.unzip3

Answer 2

I, like Mark, am wondering what you are trying to accomplish with this, but nevertheless, here is one way how you could do it:
open System
open System.Linq
// Helpers to recreate your circumstances.
type Context = { id : Int32; col1 : Nullable<Double>; col2 : Nullable<Double>; col3 : Nullable<Double>}
let context = Unchecked.defaultof<IQueryable<Context>>
let result = query { for row in context do
where (row.id = 111111)
select (row.col1,row.col2,row.col3) }
let seqTuple =
result
|> Seq.fold (fun (col1s, col2s, col3s) (col1, col2, col3) ->
(if col1.HasValue then col1.Value :: col1s else col1s),
(if col2.HasValue then col2.Value :: col2s else col2s),
(if col3.HasValue then col3.Value :: col3s else col3s)
) ([], [], [])
|> fun (col1s, col2s, col3s) ->
List.rev col1s,
List.rev col2s,
List.rev col3s