Merge pull request #208 from fsprojects/refactoring-datatable-constructors

Refactoring - getting rid of datatable constructors mess

Author: dmitry-a-morozov

src/SqlClient/DataTable.fs

@@ -8,31 +8,10 @@ open FSharp.Data.SqlClient
 
 [<Sealed>]
 [<CompilerMessageAttribute("This API supports the FSharp.Data.SqlClient infrastructure and is not intended to be used directly from your code.", 101, IsHidden = true)>]
-type DataTable<'T when 'T :> DataRow> private (tableName, knownSelectCommand, getDesignTimeConnection:Lazy<_>) = 
-    inherit DataTable(tableName)
+type DataTable<'T when 'T :> DataRow>(selectCommand: SqlCommand, ?connectionString: Lazy<string>) = 
+    inherit DataTable()
 
     let rows = base.Rows
-    let getSelectCommand maybeRuntimeConnection maybeRuntimeTransaction =
-        let makeSelectCommand connection = 
-            let selectCommand = new SqlCommand("SELECT * FROM " + tableName)
-            selectCommand.Connection <- connection
-            selectCommand
-
-        if Option.isSome knownSelectCommand
-        then 
-            knownSelectCommand.Value
-        else
-            match maybeRuntimeTransaction, maybeRuntimeConnection with
-            | Some (tran:SqlTransaction), _ -> 
-                let command = makeSelectCommand tran.Connection
-                command.Transaction <- tran
-                command
-            | None, Some connection ->  
-                makeSelectCommand connection
-            | _ -> makeSelectCommand (getDesignTimeConnection.Value)
-
-    new (tableName, getDesignTimeConnection) = new DataTable<'T>(tableName, None, getDesignTimeConnection)
-    new (createCommand) = new DataTable<'T>(null, Some createCommand, lazy(createCommand.Connection))
 
     member __.Rows : IList<'T> = {
         new IList<'T> with
@@ -59,9 +38,18 @@ type DataTable<'T when 'T :> DataRow> private (tableName, knownSelectCommand, ge
 
     member __.NewRow(): 'T = downcast base.NewRow()
 
+    member private this.IsDirectTable = this.TableName <> null
+    
     member this.Update(?connection, ?transaction, ?batchSize) = 
 
-        let selectCommand = getSelectCommand connection transaction
+        connection |> Option.iter selectCommand.set_Connection
+        transaction |> Option.iter selectCommand.set_Transaction 
+        
+        if selectCommand.Connection = null && this.IsDirectTable 
+        then 
+            assert(connectionString.IsSome)
+            selectCommand.Connection <- new SqlConnection( connectionString.Value.Value)
+
         use dataAdapter = new SqlDataAdapter(selectCommand)
         use commandBuilder = new SqlCommandBuilder(dataAdapter) 
         use __ = dataAdapter.RowUpdating.Subscribe(fun args ->
@@ -88,24 +76,29 @@ type DataTable<'T when 'T :> DataRow> private (tableName, knownSelectCommand, ge
                     cmd.UpdatedRowSource <- UpdateRowSource.FirstReturnedRecord
         )
 
-        connection |> Option.iter dataAdapter.SelectCommand.set_Connection
-        transaction |> Option.iter dataAdapter.SelectCommand.set_Transaction
         batchSize |> Option.iter dataAdapter.set_UpdateBatchSize
 
         dataAdapter.Update(this)
 
     member this.BulkCopy(?connection, ?copyOptions, ?transaction, ?batchSize, ?timeout: TimeSpan) = 
 
-        let selectCommand = getSelectCommand connection transaction
-        let connection = defaultArg connection selectCommand.Connection
-        use __ = connection.UseLocally()
-        use bulkCopy = 
-            new SqlBulkCopy(
-                connection, 
-                copyOptions = defaultArg copyOptions SqlBulkCopyOptions.Default, 
-                externalTransaction = defaultArg transaction selectCommand.Transaction
-            )
-        bulkCopy.DestinationTableName <- tableName
+        let conn', tran' = 
+            match connection, transaction with
+            | _, Some(t: SqlTransaction) -> t.Connection, t
+            | Some c, None -> c, null
+            | None, None ->
+                if this.IsDirectTable
+                then 
+                    assert(connectionString.IsSome)
+                    new SqlConnection(connectionString.Value.Value), null
+                else
+                    selectCommand.Connection, selectCommand.Transaction
+
+        use __ = conn'.UseLocally()
+        let options = defaultArg copyOptions SqlBulkCopyOptions.Default
+        use bulkCopy = new SqlBulkCopy(conn', options, tran')
+        bulkCopy.DestinationTableName <- this.TableName
         batchSize |> Option.iter bulkCopy.set_BatchSize
         timeout |> Option.iter (fun x -> bulkCopy.BulkCopyTimeout <- int x.TotalSeconds)
-        bulkCopy.WriteToServer this
+        bulkCopy.WriteToServer this
+

src/SqlClient/SqlClient.fsproj

@@ -84,7 +84,7 @@
     <Compile Include="SqlCommandProvider.fs" />
     <Compile Include="SqlClientProvider.fs" />
     <Compile Include="SqlEnumProvider.fs" />
-    <Compile Include="Scripts\Scratchpad.fsx" />
+    <None Include="Scripts\Scratchpad.fsx" />
     <None Include="Scripts\XE.fsx" />
     <None Include="packages.config" />
   </ItemGroup>

src/SqlClient/SqlClientProvider.fs

@@ -370,9 +370,10 @@ type public SqlProgrammabilityProvider(config : TypeProviderConfig) as this =
 
                         <@@ 
 
-                            let connection = lazy 
-                                                 new SqlConnection( %%connectionString.RunTimeValueExpr(config.IsHostedExecution))
-                            let table = new DataTable<DataRow>(twoPartTableName, connection)
+                            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