Enable typed data table constructor to initialize an empty datatable with the expected columns.

Author: smoothdeveloper

src/SqlClient.Tests/DataTablesTests.fs

@@ -407,3 +407,25 @@ type DataTablesTests() =
 
         Assert.Equal(1, rowsAffected)
 
+    [<Fact>]
+    member __.``can build arbitrary data table from inline sql``() =
+        use table = new SqlCommandProvider<"SELECT 1 a, 2 b", ConnectionStrings.AdventureWorksNamed, ResultType.DataTable>.Table()
+        let r = table.NewRow()
+        table.Columns.a.set_ReadOnly false
+        table.Columns.a.SetValue(r, 2)
+        Assert.Equal(r.a , 2)
+        
+    [<Fact>]
+    member __.``can build arbitrary table and columns exist``() =
+        let t = new GetArbitraryDataAsDataTable.Table()
+        let r = t.NewRow()
+        t.Columns.a.set_ReadOnly false
+        t.Columns.a.SetValue(r, 1)
+        Assert.Equal(r.a , 1)
+               
+    [<Fact>]
+    member __.``can't update on arbitrarilly constructed table``() =
+        let t = new GetArbitraryDataAsDataTable.Table()
+        let e = Assert.Throws(fun () -> t.Update() |> ignore)
+        Assert.Equal<string>("This command wasn't constructed from SqlProgrammabilityProvider, call to Update is not supported.", e.Message)
+       

src/SqlClient/DataTable.fs

@@ -41,7 +41,11 @@ type DataTable<'T when 'T :> DataRow>(selectCommand: SqlCommand, ?connectionStri
     member private this.IsDirectTable = this.TableName <> null
 
     member this.Update(?connection, ?transaction, ?batchSize, ?continueUpdateOnError) = 
-        
+        // not supported on all DataTable instances
+        match selectCommand with
+        | null -> failwith "This command wasn't constructed from SqlProgrammabilityProvider, call to Update is not supported."
+        | _ -> ()
+
         connection |> Option.iter selectCommand.set_Connection
         transaction |> Option.iter selectCommand.set_Transaction 
 
@@ -88,6 +92,9 @@ type DataTable<'T when 'T :> DataRow>(selectCommand: SqlCommand, ?connectionStri
             | _, Some(t: SqlTransaction) -> t.Connection, t
             | Some c, None -> c, null
             | None, None ->
+                match selectCommand with
+                | null -> failwith "To issue BulkCopy on this table, you need to provide your own connection or transaction"
+                | _ -> ()
                 if this.IsDirectTable
                 then 
                     assert(connectionString.IsSome)

src/SqlClient/DesignTime.fs

@@ -12,6 +12,28 @@ open ProviderImplementation.ProvidedTypes
 open FSharp.Data
 open System.Text.RegularExpressions
 
+module RuntimeInternals =
+    let setupTableFromSerializedColumns (serializedSchema: string) (table: System.Data.DataTable) =
+        let primaryKey = ResizeArray()
+        for line in serializedSchema.Split('\n') do
+            let xs = line.Split('\t')
+            let col = new DataColumn()
+            col.ColumnName <- xs.[0]
+            col.DataType <- Type.GetType( xs.[1], throwOnError = true)  
+            col.AllowDBNull <- Boolean.Parse xs.[2]
+            if col.DataType = typeof<string>
+            then 
+                col.MaxLength <- int xs.[3]
+            col.ReadOnly <- Boolean.Parse xs.[4]
+            col.AutoIncrement <- Boolean.Parse xs.[5]
+            if Boolean.Parse xs.[6]
+            then    
+                primaryKey.Add col 
+            table.Columns.Add col
+
+        table.PrimaryKey <- Array.ofSeq primaryKey
+
+
 type internal RowType = {
     Provided: Type
     ErasedTo: Type
@@ -31,6 +53,10 @@ type internal ReturnType = {
         | Some x -> Expr.Value( x.ErasedTo.AssemblyQualifiedName)
         | None -> <@@ null: string @@>
 
+type internal DataTableType =
+| SqlProgrammabilityTable of isHostedExecution: bool * connectionString: DesignTimeConnectionString * schemaName: string * tableName: string * columns: Column list
+| CommandResultTable 
+
 module internal SharedLogic =
     /// Adds .Record or .Table inner type depending on resultType
     let alterReturnTypeAccordingToResultType (returnType: ReturnType) (cmdProvidedType: ProvidedTypeDefinition) resultType =
@@ -246,7 +272,7 @@ type DesignTime private() =
 
         rowType
 
-    static member internal GetDataTableType(typeName, dataRowType: ProvidedTypeDefinition, outputColumns: Column list) =
+    static member internal GetDataTableType(typeName, dataRowType: ProvidedTypeDefinition, outputColumns: Column list, dataTableType: DataTableType) =
         let tableType = ProvidedTypeBuilder.MakeGenericType(typedefof<_ DataTable>, [ dataRowType ])
         let tableProvidedType = ProvidedTypeDefinition(typeName, Some tableType)
 
@@ -325,6 +351,41 @@ type DesignTime private() =
             )
         dataRowType.AddMember tableProperty
 
+        let getColumnsSerializedSchema columns =
+            columns 
+            |> List.map (fun x ->
+                let nullable = x.Nullable || x.HasDefaultConstraint
+                sprintf "%s\t%s\t%b\t%i\t%b\t%b\t%b" 
+                    x.Name x.TypeInfo.ClrTypeFullName nullable x.MaxLength x.ReadOnly x.Identity x.PartOfUniqueKey                                 
+            ) 
+            |> String.concat "\n"
+
+        let ctorCode =
+            fun _ ->
+                let serializedSchema = getColumnsSerializedSchema outputColumns
+                match dataTableType with
+                | SqlProgrammabilityTable (isHostedExecution, connectionString, schemaName, tableName, _) ->
+                    
+                    let twoPartTableName = sprintf "[%s].[%s]" schemaName tableName 
+
+                    <@@ 
+                        let connectionString = lazy %%connectionString.RunTimeValueExpr(isHostedExecution)
+                        let selectCommand = new SqlCommand("SELECT * FROM " + twoPartTableName)
+                        let table = new DataTable<DataRow>(selectCommand, connectionString)
+                        table.TableName <- twoPartTableName
+                        RuntimeInternals.setupTableFromSerializedColumns serializedSchema table
+                        table
+                    @@>
+                | CommandResultTable ->
+                    <@@ 
+                        let table = new DataTable<DataRow>(null, null)
+                        RuntimeInternals.setupTableFromSerializedColumns serializedSchema table
+                        table
+                    @@>
+          
+
+        ProvidedConstructor([], InvokeCode = ctorCode) |> tableProvidedType.AddMember
+
         tableProvidedType
 
     static member internal GetOutputTypes (outputColumns: Column list, resultType, rank: ResultRank, hasOutputParameters, ?unitsOfMeasurePerSchema) =    
@@ -337,7 +398,7 @@ type DesignTime private() =
         elif resultType = ResultType.DataTable 
         then
             let dataRowType = DesignTime.GetDataRowType(outputColumns, ?unitsOfMeasurePerSchema = unitsOfMeasurePerSchema)
-            let dataTableType = DesignTime.GetDataTableType("Table", dataRowType, outputColumns)
+            let dataTableType = DesignTime.GetDataTableType("Table", dataRowType, outputColumns, CommandResultTable)
             dataTableType.AddMember dataRowType
 
             { Single = dataTableType; PerRow = None }
@@ -807,4 +868,3 @@ type DesignTime private() =
                 | None -> m.Groups.[0].Value))
 
         (vars |> Array.map(fun (name,typ) -> sprintf "DECLARE %s%s %s = @%s" Prefixes.tableVar name typ name) |> String.concat "; ") + "; " + commandText
-

src/SqlClient/SqlClientProvider.fs

@@ -248,8 +248,6 @@ type SqlProgrammabilityProvider(config : TypeProviderConfig) as this =
             conn.GetTables(schema, isSqlAzure)
             |> List.map (fun (tableName, baseTableName, baseSchemaName, description) -> 
 
-                let twoPartTableName = sprintf "[%s].[%s]" schema tableName 
-
                 let descriptionSelector = 
                     if isSqlAzure 
                     then "(SELECT NULL AS Value)"
@@ -352,55 +350,13 @@ type SqlProgrammabilityProvider(config : TypeProviderConfig) as this =
                         dataRowType.AddMember property
 
                 //type data table
-                let dataTableType = DesignTime.GetDataTableType(tableName, dataRowType, columns)
+                let dataTableType = DesignTime.GetDataTableType(tableName, dataRowType, columns, SqlProgrammabilityTable(config.IsHostedExecution, connectionString, schema, tableName, columns))
                 tagProvidedType dataTableType
                 dataTableType.AddMember dataRowType
 
                 do
                     description |> Option.iter (fun x -> dataTableType.AddXmlDoc( sprintf "<summary>%s</summary>" x))
 
-                do //ctor
-                    let ctor = ProvidedConstructor []
-                    ctor.InvokeCode <- fun _ -> 
-                        let serializedSchema = 
-                            columns 
-                            |> List.map (fun x ->
-                                let nullable = x.Nullable || x.HasDefaultConstraint
-                                sprintf "%s\t%s\t%b\t%i\t%b\t%b\t%b" 
-                                    x.Name x.TypeInfo.ClrTypeFullName nullable x.MaxLength x.ReadOnly x.Identity x.PartOfUniqueKey                                 
-                            ) 
-                            |> String.concat "\n"
-
-                        <@@ 
-                            
-                            let connectionString = lazy %%connectionString.RunTimeValueExpr(config.IsHostedExecution)
-                            let selectCommand = new SqlCommand("SELECT * FROM " + twoPartTableName)
-                            let table = new DataTable<DataRow>(selectCommand, connectionString)
-                            table.TableName <- twoPartTableName
-
-                            let primaryKey = ResizeArray()
-                            for line in serializedSchema.Split('\n') do
-                                let xs = line.Split('\t')
-                                let col = new DataColumn()
-                                col.ColumnName <- xs.[0]
-                                col.DataType <- Type.GetType( xs.[1], throwOnError = true)  
-                                col.AllowDBNull <- Boolean.Parse xs.[2]
-                                if col.DataType = typeof<string>
-                                then 
-                                    col.MaxLength <- int xs.[3]
-                                col.ReadOnly <- Boolean.Parse xs.[4]
-                                col.AutoIncrement <- Boolean.Parse xs.[5]
-                                if Boolean.Parse xs.[6]
-                                then    
-                                    primaryKey.Add col 
-                                table.Columns.Add col
-
-                            table.PrimaryKey <- Array.ofSeq primaryKey
-
-                            table
-                        @@>
-                    dataTableType.AddMember ctor
-                
                 do
                     let parameters, updateableColumns = 
                         [