anchor.diff:          | _  -> None 
       | _ -> None 
   
  +module SqlDataReader = 
  +
  +    let internal map mapping (reader: SqlDataReader) = 
  +        reader |> Seq.unfold (fun current -> if current.Read() then Some( mapping reader, current) else None) 
  +
  +    let internal getOption<'a> (key: string) (reader: SqlDataReader) =
  +        let v = reader.[key] 
  +        if v = DbNull then None else Some(unbox<'a> v)
  +        
   type SqlConnection with
   
    //address an issue when regular Dispose on SqlConnection needed for async computation 
  
positive.code:     let dbTypes = dataTypeMappings.[connStr] 
      dbTypes|> Array.find(fun x -> x.TypeName = name || x.UdttName = name)
  
  let splitName (twoPartsName : string) =
     let parts = twoPartsName.Split('.')
     parts.[0], parts.[1]
  
  let internal ReturnValue (conn : SqlConnection) = { 
      Name = "@ReturnValue" 
      Direction = ParameterDirection.ReturnValue
      TypeInfo = findTypeInfoByName ( conn.ConnectionString, "int") 
      DefaultValue = None }
  
  type SqlDataReader with
      member this.toOption<'a> (key:string) =
          let v = this.[key] 
          if v = DbNull then None else Some(unbox<'a> v)
      
  
  type DataRow with
      member this.toOption<'a> (key:string) = if this.IsNull(key) then None else Some(unbox<'a> this.[key])
  
negative.code:         use reader = cmd.ExecuteReader()
  
          while reader.Read() do
              let user_type_id = reader |> SqlDataReader.getOption<int> "user_type_id"
              let system_type_id = reader.["system_type_id"] |> unbox<int>
              yield { 
                  Column.Name = string reader.["name"]
  