/// <summary> /// Used to issue a Save command on an esEntity or tgEntityCollection. /// </summary> /// <param name="request">Contains all of the information necessary to issue and carry out the request</param> /// <param name="sig">Contains the required information to locate the EntitySpaces DataProvider</param> /// <returns></returns> public tgDataResponse esSaveDataTable(tgDataRequest request, tgProviderSignature sig) { request.DatabaseVersion = sig.DatabaseVersion; tgDataResponse response = tgProviderFactory.GetDataProvider(sig.DataProviderName, sig.DataProviderClass).esSaveDataTable(request); // NOTE: New to 1.6.0. We do not rethrow the exception here, we do rethrow it in // tgEntityCollection.SaveToProviderInsertsUpdates after we assign the errors to the proper rows. return(response); }
/// <summary> /// Similiar to esLoadDataTable only this method merely returns a DataTable and does not /// actually populate an esEntity or tgEntityCollection. /// </summary> /// <param name="request">Contains all of the information necessary to issue and carry out the request</param> /// <param name="sig">Contains the required information to locate the EntitySpaces DataProvider</param> /// <returns></returns> public tgDataResponse FillDataTable(tgDataRequest request, tgProviderSignature sig) { request.DatabaseVersion = sig.DatabaseVersion; tgDataResponse response = tgProviderFactory.GetDataProvider(sig.DataProviderName, sig.DataProviderClass).FillDataTable(request); if (response.IsException) { throw response.Exception; } return(response); }
/// <summary> /// Execute the query and return a single value. /// </summary> /// <returns>The value</returns> virtual public T ExecuteScalar <T>() { FixupSerializedQueries(); tgDataRequest request = new tgDataRequest(); this.PopulateRequest(request); tgDataProvider provider = new tgDataProvider(); tgDataResponse response = provider.ExecuteScalar(request, this.tg2.Connection.ProviderSignature); return((T)response.Scalar); }
/// <summary> /// Execute the Query and loads your BusinessEntity. /// If you need to be notified that this is being called /// override BusinessEntity.Query.OnLoadEvent(). /// </summary> /// <remarks> /// The default conjunction is AND. /// You can change the default conjunction this way: /// <code> /// emps.Query.es.DefaultConjunction = tgConjunction.Or; /// </code> /// </remarks> /// <returns>True if at least one record was loaded</returns> virtual public bool Load() { bool loaded = false; DataTable table = null; FixupSerializedQueries(); tgDataRequest request = new tgDataRequest(); this.PopulateRequest(request); tgDataProvider provider = new tgDataProvider(); tgDataResponse response = provider.esLoadDataTable(request, this.tg2.Connection.ProviderSignature); table = response.Table; if (prefetchMaps != null) { foreach (tgPrefetchMap map in prefetchMaps) { // Give our Prefetch Queries the proper connection strings if (!map.Query.tg2.HasConnection) { string generatedName = this.GetConnectionName(); if (generatedName != null) { // Use the connection name typed into the generated master when they // generated the code map.Query.tg2.Connection.Name = generatedName; } else { // Use the connection from the Collection/Entity at the time they // call Load() map.Query.tg2.Connection.Name = this.connection.Name; } } map.Table = map.Query.LoadDataTable(); } } if (this.OnLoadDelegate != null) { loaded = OnLoadDelegate(this, table); } return(loaded); }
/// <summary> /// This merely parses and returns the SQL Syntax, no SQL is executed. /// </summary> /// <remarks> /// The default conjunction is AND. /// You can change the default conjunction this way: /// <code> /// emps.Query.es.DefaultConjunction = tgConjunction.Or; /// </code> /// </remarks> /// <returns>The SQL Syntax, the same as query.es.LastQuery when a query is executed.</returns> virtual public string Parse() { FixupSerializedQueries(); tgDataRequest request = new tgDataRequest(); this.PopulateRequest(request); request.QueryType = tgQueryType.DynamicQueryParseOnly; tgDataProvider provider = new tgDataProvider(); tgDataResponse response = provider.esLoadDataTable(request, this.tg2.Connection.ProviderSignature); return(response.LastQuery); }
/// <summary> /// Used to execute a non-data return query through the EntitySpaces DataProvider /// </summary> /// <param name="request">Contains all of the information necessary to issue and carry out the request</param> /// <param name="sig">Contains the required information to locate the EntitySpaces DataProvider</param> /// <returns></returns> public tgDataResponse ExecuteNonQuery(tgDataRequest request, tgProviderSignature sig) { request.DatabaseVersion = sig.DatabaseVersion; tgDataResponse response = tgProviderFactory.GetDataProvider(sig.DataProviderName, sig.DataProviderClass).ExecuteNonQuery(request); if (response.IsException) { throw response.Exception; } if (response.Parameters != null && response.Parameters.Count > 0) { request.Parameters.Merge(response.Parameters); } return(response); }
/// <summary> /// Execute the Query and load a DataTable. /// </summary> /// <returns>A DataTable containing the loaded records.</returns> virtual public DataTable LoadDataTable() { DataTable table = null; FixupSerializedQueries(); tgDataRequest request = new tgDataRequest(); this.PopulateRequest(request); tgDataProvider provider = new tgDataProvider(); tgDataResponse response = provider.esLoadDataTable(request, this.tg2.Connection.ProviderSignature); table = response.Table; return(table); }
/// <summary> /// Used to populate an esEntity or tgEntityCollection with data. /// </summary> /// <param name="request">Contains all of the information necessary to issue and carry out the request</param> /// <param name="sig">Contains the required information to locate the EntitySpaces DataProvider</param> /// <returns></returns> public tgDataResponse esLoadDataTable(tgDataRequest request, tgProviderSignature sig) { request.DatabaseVersion = sig.DatabaseVersion; tgDataResponse response = tgProviderFactory.GetDataProvider(sig.DataProviderName, sig.DataProviderClass).esLoadDataTable(request); if (request.DynamicQuery != null) { request.DynamicQuery.tg.LastQuery = response.LastQuery; } if (response.IsException) { throw response.Exception; } return(response); }
public static void GatherReturnParameters(MySqlCommand cmd, tgDataRequest request, tgDataResponse response) { if (cmd.Parameters.Count > 0) { if (request.Parameters != null && request.Parameters.Count > 0) { string paramPrefix = request.ProviderMetadata.spLoadByPrimaryKey == cmd.CommandText ? Delimiters.Param + "p" : Delimiters.Param; response.Parameters = new tgParameters(); foreach (tgParameter esParam in request.Parameters) { if (esParam.Direction != tgParameterDirection.Input) { response.Parameters.Add(esParam); MySqlParameter p = cmd.Parameters[paramPrefix + esParam.Name]; esParam.Value = p.Value; } } } } }
public static void GatherReturnParameters(OracleCommand cmd, tgDataRequest request, tgDataResponse response) { if (cmd.Parameters.Count > 0) { if (request.Parameters != null && request.Parameters.Count > 0) { string paramPrefix = request.QueryType == tgQueryType.StoredProcedure ? String.Empty : Delimiters.Param; paramPrefix = request.ProviderMetadata.spLoadByPrimaryKey == request.QueryText ? "p" : paramPrefix; response.Parameters = new tgParameters(); foreach (tgParameter esParam in request.Parameters) { if (esParam.Direction != tgParameterDirection.Input) { response.Parameters.Add(esParam); OracleParameter p = cmd.Parameters[paramPrefix + esParam.Name]; esParam.Value = p.Value; } } } } }
private static tgDataResponse LoadManyToMany(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); NpgsqlCommand cmd = null; try { DataTable dataTable = new DataTable(request.ProviderMetadata.Destination); cmd = new NpgsqlCommand(); cmd.CommandType = CommandType.Text; if (request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; string mmQuery = request.QueryText; string[] sections = mmQuery.Split('|'); string[] tables = sections[0].Split(','); string[] columns = sections[1].Split(','); string prefix = String.Empty; if (request.Catalog != null || request.ProviderMetadata.Catalog != null) { prefix += Delimiters.TableOpen; prefix += request.Catalog != null ? request.Catalog : request.ProviderMetadata.Catalog; prefix += Delimiters.TableClose + "."; } if (request.Schema != null || request.ProviderMetadata.Schema != null) { prefix += Delimiters.TableOpen; prefix += request.Schema != null ? request.Schema : request.ProviderMetadata.Schema; prefix += Delimiters.TableClose + "."; } string table0 = prefix + Delimiters.TableOpen + tables[0] + Delimiters.TableClose; string table1 = prefix + Delimiters.TableOpen + tables[1] + Delimiters.TableClose; string sql = "SELECT * FROM " + table0 + " JOIN " + table1 + " ON " + table0 + ".\"" + columns[0] + "\" = "; sql += table1 + ".\"" + columns[1] + "\" WHERE " + table1 + ".\"" + sections[2] + "\" = @"; if (request.Parameters != null) { foreach (tgParameter esParam in request.Parameters) { sql += esParam.Name; } Shared.AddParameters(cmd, request); } NpgsqlDataAdapter da = new NpgsqlDataAdapter(); cmd.CommandText = sql; da.SelectCommand = cmd; try { tgTransactionScope.Enlist(da.SelectCommand, request.ConnectionString, CreateIDbConnectionDelegate); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "LoadManyToMany", System.Environment.StackTrace)) { try { da.Fill(dataTable); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion Profiling { da.Fill(dataTable); } } finally { tgTransactionScope.DeEnlist(da.SelectCommand); } response.Table = dataTable; } catch (Exception ex) { CleanupCommand(cmd); throw ex; } finally { } return response; }
private static tgDataResponse LoadDataTableFromText(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); NpgsqlCommand cmd = null; try { DataTable dataTable = new DataTable(request.ProviderMetadata.Destination); cmd = new NpgsqlCommand(); cmd.CommandType = CommandType.Text; if (request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; if (request.Parameters != null) Shared.AddParameters(cmd, request); NpgsqlDataAdapter da = new NpgsqlDataAdapter(); cmd.CommandText = request.QueryText; da.SelectCommand = cmd; try { tgTransactionScope.Enlist(da.SelectCommand, request.ConnectionString, CreateIDbConnectionDelegate); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "LoadFromText", System.Environment.StackTrace)) { try { da.Fill(dataTable); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion Profiling { da.Fill(dataTable); } } finally { tgTransactionScope.DeEnlist(da.SelectCommand); } response.Table = dataTable; if (request.Parameters != null) { Shared.GatherReturnParameters(cmd, request, response); } } catch (Exception ex) { CleanupCommand(cmd); throw ex; } finally { } return response; }
// This is used only to execute the Dynamic Query API private static void LoadDataTableFromDynamicQuery(tgDataRequest request, tgDataResponse response, NpgsqlCommand cmd) { try { response.LastQuery = cmd.CommandText; if (request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; DataTable dataTable = new DataTable(request.ProviderMetadata.Destination); NpgsqlDataAdapter da = new NpgsqlDataAdapter(); da.SelectCommand = cmd; try { tgTransactionScope.Enlist(da.SelectCommand, request.ConnectionString, CreateIDbConnectionDelegate); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "LoadFromDynamicQuery", System.Environment.StackTrace)) { try { da.Fill(dataTable); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion Profiling { da.Fill(dataTable); } } finally { tgTransactionScope.DeEnlist(da.SelectCommand); } response.Table = dataTable; } catch (Exception ex) { CleanupCommand(cmd); throw ex; } finally { } }
tgDataResponse IDataProvider.FillDataTable(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); try { switch (request.QueryType) { case tgQueryType.StoredProcedure: response = LoadDataTableFromStoredProcedure(request); break; case tgQueryType.Text: response = LoadDataTableFromText(request); break; default: break; } } catch (Exception ex) { response.Exception = ex; } return response; }
tgDataResponse IDataProvider.ExecuteScalar(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); NpgsqlCommand cmd = null; try { cmd = new NpgsqlCommand(); if (request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; if (request.Parameters != null) Shared.AddParameters(cmd, request); switch (request.QueryType) { case tgQueryType.TableDirect: cmd.CommandType = CommandType.TableDirect; cmd.CommandText = request.QueryText; break; case tgQueryType.StoredProcedure: cmd.CommandType = CommandType.StoredProcedure; cmd.CommandText = Shared.CreateFullName(request); break; case tgQueryType.Text: cmd.CommandType = CommandType.Text; cmd.CommandText = request.QueryText; break; case tgQueryType.DynamicQuery: cmd = QueryBuilder.PrepareCommand(request); break; } try { tgTransactionScope.Enlist(cmd, request.ConnectionString, CreateIDbConnectionDelegate); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "ExecuteScalar", System.Environment.StackTrace)) { try { response.Scalar = cmd.ExecuteScalar(); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion Profiling { response.Scalar = cmd.ExecuteScalar(); } } finally { tgTransactionScope.DeEnlist(cmd); } if (request.Parameters != null) { Shared.GatherReturnParameters(cmd, request, response); } } catch (Exception ex) { CleanupCommand(cmd); response.Exception = ex; } return response; }
tgDataResponse IDataProvider.ExecuteReader(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); NpgsqlCommand cmd = null; try { cmd = new NpgsqlCommand(); if (request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; if (request.Parameters != null) Shared.AddParameters(cmd, request); switch (request.QueryType) { case tgQueryType.TableDirect: cmd.CommandType = CommandType.TableDirect; cmd.CommandText = request.QueryText; break; case tgQueryType.StoredProcedure: cmd.CommandType = CommandType.StoredProcedure; cmd.CommandText = Shared.CreateFullName(request); break; case tgQueryType.Text: cmd.CommandType = CommandType.Text; cmd.CommandText = request.QueryText; break; case tgQueryType.DynamicQuery: cmd = QueryBuilder.PrepareCommand(request); break; } cmd.Connection = new NpgsqlConnection(request.ConnectionString); cmd.Connection.Open(); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "ExecuteReader", System.Environment.StackTrace)) { try { response.DataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion Profiling { response.DataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection); } } catch (Exception ex) { CleanupCommand(cmd); response.Exception = ex; } return response; }
tgDataResponse IDataProvider.ExecuteNonQuery(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); OleDbCommand cmd = null; try { cmd = new OleDbCommand(); if(request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; if(request.Parameters != null) AddParameters(cmd, request); cmd.CommandText = request.QueryText; switch (request.QueryType) { case tgQueryType.TableDirect: cmd.CommandType = CommandType.TableDirect; break; case tgQueryType.StoredProcedure: cmd.CommandType = CommandType.StoredProcedure; break; case tgQueryType.Text: cmd.CommandType = CommandType.Text; break; } try { tgTransactionScope.Enlist(cmd, request.ConnectionString, CreateIDbConnectionDelegate); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "ExecuteNonQuery", System.Environment.StackTrace)) { try { response.RowsEffected = cmd.ExecuteNonQuery(); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion { response.RowsEffected = cmd.ExecuteNonQuery(); } } finally { tgTransactionScope.DeEnlist(cmd); } } catch (Exception ex) { CleanupCommand(cmd); response.Exception = ex; } return response; }
private static tgDataResponse LoadDataSetFromStoredProcedure(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); SQLiteCommand cmd = null; try { DataSet dataSet = new DataSet(); cmd = new SQLiteCommand(); cmd.CommandType = CommandType.StoredProcedure; cmd.CommandText = Shared.CreateFullName(request); if (request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; if (request.Parameters != null) Shared.AddParameters(cmd, request); SQLiteDataAdapter da = new SQLiteDataAdapter(); da.SelectCommand = cmd; try { tgTransactionScope.Enlist(da.SelectCommand, request.ConnectionString, CreateIDbConnectionDelegate); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "LoadFromStoredProcedure", System.Environment.StackTrace)) { try { da.Fill(dataSet); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion Profiling { da.Fill(dataSet); } } finally { tgTransactionScope.DeEnlist(da.SelectCommand); } response.DataSet = dataSet; if (request.Parameters != null) { Shared.GatherReturnParameters(cmd, request, response); } } catch (Exception ex) { CleanupCommand(cmd); throw ex; } finally { } return response; }
private static tgDataResponse LoadManyToMany(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); SQLiteCommand cmd = null; try { DataTable dataTable = new DataTable(request.ProviderMetadata.Destination); cmd = new SQLiteCommand(); cmd.CommandType = CommandType.Text; if (request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; string mmQuery = request.QueryText; string[] sections = mmQuery.Split('|'); string[] tables = sections[0].Split(','); string[] columns = sections[1].Split(','); // We build the query, we don't use Delimiters to avoid tons of extra concatentation string sql = "SELECT * FROM [" + tables[0]; sql += "] JOIN [" + tables[1] + "] ON [" + tables[0] + "].[" + columns[0] + "] = ["; sql += tables[1] + "].[" + columns[1]; sql += "] WHERE [" + tables[1] + "].[" + sections[2] + "] = @"; if (request.Parameters != null) { foreach (tgParameter esParam in request.Parameters) { sql += esParam.Name; } Shared.AddParameters(cmd, request); } SQLiteDataAdapter da = new SQLiteDataAdapter(); cmd.CommandText = sql; da.SelectCommand = cmd; try { tgTransactionScope.Enlist(da.SelectCommand, request.ConnectionString, CreateIDbConnectionDelegate); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "LoadManyToMany", System.Environment.StackTrace)) { try { da.Fill(dataTable); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion Profiling { da.Fill(dataTable); } } finally { tgTransactionScope.DeEnlist(da.SelectCommand); } response.Table = dataTable; } catch (Exception ex) { CleanupCommand(cmd); throw ex; } finally { } return response; }
tgDataResponse IDataProvider.esSaveDataTable(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); try { if (request.EntitySavePacket.CurrentValues == null) SaveDynamicCollection(request); else SaveDynamicEntity(request); } catch (SqlCeException ex) { tgException es = Shared.CheckForConcurrencyException(ex); if (es != null) response.Exception = es; else response.Exception = ex; } catch (DBConcurrencyException dbex) { response.Exception = new tgConcurrencyException("Error in SqlServerCeProvider.esSaveDataTable", dbex); } response.Table = request.Table; return response; }
private static tgDataResponse LoadDataTableFromStoredProcedure(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); OracleCommand cmd = null; try { DataTable dataTable = new DataTable(request.ProviderMetadata.Destination); cmd = new OracleCommand(); cmd.CommandType = CommandType.StoredProcedure; cmd.CommandText = Shared.CreateFullName(request); if (request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; if (request.Parameters != null) Shared.AddParameters(cmd, request); OracleParameter p = new OracleParameter("outCursor", OracleType.Cursor); p.Direction = ParameterDirection.Output; cmd.Parameters.Add(p); OracleDataAdapter da = new OracleDataAdapter(); da.SelectCommand = cmd; try { tgTransactionScope.Enlist(da.SelectCommand, request.ConnectionString, CreateIDbConnectionDelegate); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "LoadFromStoredProcedure", System.Environment.StackTrace)) { try { da.Fill(dataTable); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion { da.Fill(dataTable); } } finally { tgTransactionScope.DeEnlist(da.SelectCommand); } response.Table = dataTable; if (request.Parameters != null) { Shared.GatherReturnParameters(cmd, request, response); } } catch (Exception) { CleanupCommand(cmd); throw; } finally { } return response; }
tgDataResponse IDataProvider.esLoadDataTable(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); try { switch (request.QueryType) { case tgQueryType.StoredProcedure: response = LoadDataTableFromStoredProcedure(request); break; case tgQueryType.Text: response = LoadDataTableFromText(request); break; case tgQueryType.DynamicQuery: response = new tgDataResponse(); NpgsqlCommand cmd = QueryBuilder.PrepareCommand(request); LoadDataTableFromDynamicQuery(request, response, cmd); break; case tgQueryType.DynamicQueryParseOnly: response = new tgDataResponse(); NpgsqlCommand cmd1 = QueryBuilder.PrepareCommand(request); response.LastQuery = cmd1.CommandText; break; case tgQueryType.ManyToMany: response = LoadManyToMany(request); break; default: break; } } catch (Exception ex) { response.Exception = ex; } return response; }
tgDataResponse IDataProvider.esSaveDataTable(tgDataRequest request) { tgDataResponse response = new tgDataResponse(); try { if (request.SqlAccessType == tgSqlAccessType.StoredProcedure) { if (request.CollectionSavePacket != null) SaveStoredProcCollection(request); else SaveStoredProcEntity(request); } else { if (request.EntitySavePacket.CurrentValues == null) SaveDynamicCollection(request); else SaveDynamicEntity(request); } } catch (NpgsqlException ex) { tgException es = Shared.CheckForConcurrencyException(ex); if (es != null) response.Exception = es; else response.Exception = ex; } catch (DBConcurrencyException dbex) { response.Exception = new tgConcurrencyException("Error in SqlClientProvider.esSaveDataTable", dbex); } response.Table = request.Table; return response; }
public static void GatherReturnParameters(NpgsqlCommand cmd, tgDataRequest request, tgDataResponse response) { if (cmd.Parameters.Count > 0) { if (request.Parameters != null && request.Parameters.Count > 0) { response.Parameters = new tgParameters(); foreach (tgParameter esParam in request.Parameters) { if (esParam.Direction != tgParameterDirection.Input) { response.Parameters.Add(esParam); NpgsqlParameter p = cmd.Parameters[Delimiters.Param + esParam.Name]; esParam.Value = p.Value; } } } } }
// This is used only to execute the Dynamic Query API private static void LoadDataTableFromDynamicQuery(tgDataRequest request, tgDataResponse response, SqlCommand cmd) { try { response.LastQuery = cmd.CommandText; if (request.CommandTimeout != null) cmd.CommandTimeout = request.CommandTimeout.Value; DataTable dataTable = new DataTable(request.ProviderMetadata.Destination); SqlDataAdapter da = new SqlDataAdapter(); da.SelectCommand = cmd; try { tgTransactionScope.Enlist(da.SelectCommand, request.ConnectionString, CreateIDbConnectionDelegate); #region Profiling if (sTraceHandler != null) { using (esTraceArguments esTrace = new esTraceArguments(request, cmd, "LoadFromDynamicQuery", System.Environment.StackTrace)) { try { da.Fill(dataTable); } catch (Exception ex) { esTrace.Exception = ex.Message; throw; } } } else #endregion Profiling { da.Fill(dataTable); } } finally { tgTransactionScope.DeEnlist(da.SelectCommand); } response.Table = dataTable; // Special code to remove the ESRN column if paging is going on tgDynamicQuerySerializable.DynamicQueryProps es = request.DynamicQuery.tg; if (es.PageNumber.HasValue && es.PageSize.HasValue) { DataColumnCollection cols = response.Table.Columns; if (cols.Contains("ESRN")) { cols.Remove("ESRN"); } } } catch (Exception) { CleanupCommand(cmd); throw; } finally { } }