public static string JsonById(long id, string itemName, string instanceName) { var instance = CustomerFramework.Load(instanceName); var item = new ItemBuilder(itemName, instanceName); return(SqlStream.GetByQuerySimple(ItemTools.QueryById(item, id), instance.Config.ConnectionString)); }
/// <summary>Gets JSON array</summary> private void GoAction() { var d0 = DateTime.Now; string res = string.Empty; string action = this.Request.QueryString["Action"].Trim().ToUpperInvariant(); switch (action.ToUpperInvariant()) { case "GETLIST": res = this.GetList(); break; default: res = SqlStream.GetSqlStreamNoParams(action, this.instance.Config.ConnectionString); break; } var d1 = DateTime.Now; this.Response.Clear(); this.Response.Write(@"{""data"":"); this.Response.Write(res); var d2 = DateTime.Now; this.Response.Write(string.Format(CultureInfo.GetCultureInfo("en-us"), @",""Time"":""{0:#,##0} - {1:#,##0}""}}", (d1 - d0).TotalMilliseconds, (d2 - d1).TotalMilliseconds)); this.Response.Flush(); this.Response.SuppressContent = true; this.ApplicationInstance.CompleteRequest(); }
private SqlStream GetCreatedSqlStream( TimeSpan?commandTimeout = null, RecordTagAssociationManagementStrategy recordTagAssociationManagementStrategy = RecordTagAssociationManagementStrategy.AssociatedDuringPutInSprocInTransaction, int?maxConcurrentHandlingCount = null, SerializationFormat defaultSerializationFormat = SerializationFormat.Binary) { var sqlServerLocator = GetSqlServerLocator(); var resourceLocatorProtocol = new SingleResourceLocatorProtocols(sqlServerLocator); var defaultSerializerRepresentation = GetSerializerRepresentation(); var stream = new SqlStream( this.streamName, TimeSpan.FromMinutes(1), commandTimeout ?? TimeSpan.FromMinutes(3), defaultSerializerRepresentation, defaultSerializationFormat, new JsonSerializerFactory(), resourceLocatorProtocol); stream.Execute(new StandardCreateStreamOp(stream.StreamRepresentation, ExistingStreamStrategy.Skip)); stream.Execute(new UpdateStreamStoredProceduresOp(recordTagAssociationManagementStrategy, maxConcurrentHandlingCount)); return(stream); }
public void Enumerator_ReadInputStreamToDataRowsPerPartes_WithSmallBuffer_CheckReadedAllRows_StreamAndItsConnectIsClosedAfterForeach() { var cmd = new SqlCommand("SELECT * FROM TestTable", ConnectHelper.CreateConnection()); ISqlValueSerializer serializer = new SqlValueSerializerCsvSimple(); var bufferSize = 10; //ACT with ASSERT using (var sqlDataReaderStream = new SqlStream(cmd, serializer)) { var table = sqlDataReaderStream.DataTableWithoutData; Assert.AreEqual(0, table.Rows.Count); List <DataRow> rows = new List <DataRow>(); var oldPosition = sqlDataReaderStream.Position; foreach (var row in new StreamToEnumerableDataRows(sqlDataReaderStream, table, serializer, bufferSize)) { Assert.Greater(sqlDataReaderStream.Position, oldPosition); oldPosition = sqlDataReaderStream.Position; rows.Add(row); Assert.AreEqual(ConnectionState.Open, cmd.Connection.State); } //after dispose foreach is disposed readed stream too and it close connection Assert.AreEqual(ConnectionState.Closed, cmd.Connection.State); Assert.AreEqual(3, rows.Count); } }
public void GenerateSql() { WriteSql("-- SQL created by " + _config.Version); WriteSql("--"); WriteSql("-- Using Decoder: " + _streamProcessor.GetDecoderVersion()); WriteSql("--"); WriteSql("-- Packets captured on " + _streamProcessor.GetCaptureStartTime().ToString()); WriteSql("--"); WriteSql("-- Change these variables if required"); WriteSql("--"); WriteSql("set @StartingNPCTypeID = " + _config.SpawnDBID + ";"); WriteSql("set @StartingSpawnGroupID = " + _config.SpawnGroupID + ";"); WriteSql("set @StartingSpawnEntryID = " + _config.SpawnEntryID + ";"); WriteSql("set @StartingSpawn2ID = " + _config.Spawn2ID + ";"); WriteSql("set @StartingGridID = " + _config.GridDBID + ";"); WriteSql("set @StartingMerchantID = " + _config.MerchantDBID + ";"); WriteSql("set @BaseDoorID = " + _config.DoorDBID + ";"); WriteSql("set @StartingGroundSpawnID = " + _config.GroundSpawnDBID + ";"); WriteSql("set @StartingObjectID = " + _config.ObjectDBID + ";"); WriteSql("--"); WriteSql("--"); if (_config.GenerateZone) { _streamProcessor.GenerateZoneSQL(WriteSql); } if (_config.GenerateZonePoint) { _streamProcessor.GenerateZonePointSQL(_config.ZoneName, WriteSql); } if (_config.GenerateDoors) { Log("Starting to generate SQL for Doors."); _streamProcessor.GenerateDoorsSQL(_config.ZoneName, _config.DoorDBID, _config.SpawnVersion, WriteSql); Log("Finished generating SQL for Doors."); } Log("Starting to generate SQL for Spawns and/or Grids."); _streamProcessor.GenerateSpawnSQL(_config.GenerateSpawns, _config.GenerateGrids, _config.GenerateMerchants, _config.ZoneName, _config.ZoneID, _config.SpawnVersion, _config.UpdateExistingNPCTypes, _config.UseNPCTypesTint, _config.SpawnNameFilter, _config.CoalesceWaypoints, _config.GenerateInvisibleMen, WriteSql); Log("Finished generating SQL for Spawns and/or Grids."); if (_config.GenerateGroundSpawns || _config.GenerateObjects) { Log("Starting to generate SQL for Ground Spawns and/or Objects."); _streamProcessor.GenerateObjectSQL(_config.GenerateGroundSpawns, _config.GenerateObjects, _config.SpawnVersion, WriteSql); Log("Finished generating SQL for Ground Spawns and/or Objects."); } SetStatus("SQL written to " + _fileName); SqlStream.Close(); }
private void TestSqlValueSerializerForReadingAndWriting(ISqlValueSerializer p_SqlValueSerializer, int p_BufferSize) { var sql = @" DECLARE @p0 dbo.tt_ReportManagerSelectList INSERT INTO @p0 VALUES('CisloPozadavku','Neagregovan','','False','0') INSERT INTO @p0 VALUES('Mena','Neagregovan','','False','0') INSERT INTO @p0 VALUES('Tarif','Neagregovan','','False','0') INSERT INTO @p0 VALUES('Sezona','Neagregovan','','False','0') INSERT INTO @p0 VALUES('CK','Neagregovan','','False','1') INSERT INTO @p0 VALUES('CKa','Neagregovan','','False','1') INSERT INTO @p0 VALUES('P1','Neagregovan','','False','1') INSERT INTO @p0 VALUES('KrNC','Neagregovan','','False','1') INSERT INTO @p0 VALUES('PNC','Neagregovan','','False','1') INSERT INTO @p0 VALUES('KM','Neagregovan','','False','1') INSERT INTO @p0 VALUES('KC','Neagregovan','','False','1') INSERT INTO @p0 VALUES('PM','Neagregovan','','False','1') INSERT INTO @p0 VALUES('PC','Neagregovan','','False','1') INSERT INTO @p0 VALUES('SpotrebaMWh','Neagregovan','','False','0') INSERT INTO @p0 VALUES('VaR','Neagregovan','','False','1') INSERT INTO @p0 VALUES('VaRZaMWh','Neagregovan','','False','1') INSERT INTO @p0 VALUES('ZdaAkceptovany','Neagregovan','','False','9') INSERT INTO @p0 VALUES('PocetDnu','Neagregovan','','False','0') INSERT INTO @p0 VALUES('Poznamka','Neagregovan','','False','0') INSERT INTO @p0 VALUES('IdOceneni','Neagregovan','','False','1') INSERT INTO @p0 VALUES('Produkt','Neagregovan','','False','0') INSERT INTO @p0 VALUES('PozadavekCilOceneni','Neagregovan','','False','0') INSERT INTO @p0 VALUES('IdDiagram_Template','Neagregovan','','False','1') INSERT INTO @p0 VALUES('IdDiagramBurza_Template','Neagregovan','','False','1') INSERT INTO @p0 VALUES('IdOceneniCenovyElement','Neagregovan','','False','1') INSERT INTO @p0 VALUES('IdOceneniStav','Neagregovan','','False','1') INSERT INTO @p0 VALUES('IdPozadavek','Neagregovan','','False','1') INSERT INTO @p0 VALUES('Obor','Neagregovan','','False','0') INSERT INTO @p0 VALUES('IdOceneniDiagram','Neagregovan','','False','1') INSERT INTO @p0 VALUES('IdOceneniTyp','Neagregovan','','False','1') INSERT INTO @p0 VALUES('WorkflowInstanceState','Neagregovan','','False','0') INSERT INTO @p0 VALUES('WorkflowProcesState','Neagregovan','','False','0') INSERT INTO @p0 VALUES('ViditelnostDleStavuOceneni','Neagregovan','','False','9') INSERT INTO @p0 VALUES('IdPozadavekTypNakupu','Neagregovan','','False','1') DECLARE @p1 dbo.tt_ReportManagerFilterList INSERT INTO @p1 VALUES('o.IdOceneniStav','JeVSeznamu','7','','0') INSERT INTO @p1 VALUES('ob.IdObor','JeVSeznamu','2','','0') DECLARE @p2 dbo.tt_ReportManagerOrderBy INSERT INTO @p2 VALUES('IdOceneni','Sestupne') INSERT INTO @p2 VALUES('Mena','Vzestupne') EXECUTE Oept.p_rd_OceneniAkceptace @SelectList=@p0,@FilterList=@p1,@OrderBy=@p2,@SelectTop=10000,@Aggregation=0,@UserName='******' "; var cmd = new SqlCommand(sql, CreateConnection()); //ACT with ASSERT using (var sqlDataReaderStream = new SqlStream(cmd, p_SqlValueSerializer)) { var table = sqlDataReaderStream.DataTableWithoutData; Assert.AreEqual(0, table.Rows.Count); new StreamToDataTableRows().ReadStreamToDataTable(sqlDataReaderStream, table, p_SqlValueSerializer, p_BufferSize); Assert.AreEqual(6194, table.Rows.Count); } }
/// <summary>Page load event</summary> /// <param name="sender">This page</param> /// <param name="e">Event arguments</param> protected void Page_Load(object sender, EventArgs e) { var d0 = DateTime.Now; string itemName = this.Request.QueryString["ItemName"]; string instanceName = this.Request.QueryString["InstanceName"]; var instance = CustomerFramework.Load(instanceName); instance.LoadConfig(); var item = new ItemBuilder(itemName, instanceName); this.Response.Clear(); this.Response.ContentType = "application/json"; if (this.Request.QueryString["r"] == null) { this.Response.Write("FK."); this.Response.Write(itemName); this.Response.Write(" = "); } else { this.Response.Write("{\"ItemName\":\""); this.Response.Write(itemName); this.Response.Write("\",\"Data\":"); } if (itemName.Equals("user", StringComparison.OrdinalIgnoreCase)) { this.Response.Write(ItemBuilder.ListItemJson(ItemBuilder.GetActive(itemName, instance.Name, instance.Config.ConnectionString))); } else { var parameters = Request.QueryString.Keys.Cast <string>().ToDictionary(k => k, v => Request.QueryString[v]); parameters = parameters.Where(p => p.Key != "ac" && p.Key != "r" && p.Key != "itemName" && p.Key != "InstanceName").ToDictionary(v => v.Key, v => v.Value); this.Response.Write(SqlStream.GetFKStream(item, parameters, instance.Config.ConnectionString)); } if (this.Request.QueryString["r"] == null) { this.Response.Write(";"); } else { this.Response.Write(",\"Duration\":"); this.Response.Write(string.Format(CultureInfo.InvariantCulture, "{0:#0.000}", (DateTime.Now - d0).TotalMilliseconds)); this.Response.Write("}"); } this.Response.Flush(); this.Response.SuppressContent = true; this.ApplicationInstance.CompleteRequest(); }
public void SqlValueSerializerCsvWithXmlDictionaryWriter() { using (var conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Database"].ConnectionString)) { conn.Open(); var sql = "SELECT * FROM TestTable"; var cmd = new SqlCommand(sql, conn); using (var sqlDataReaderStream = new SqlStream(cmd, new SqlValueSerializerCsvWithXmlDictionaryWriter())) { SaveToFile(FileName("TestTable-XmlDictionaryWriter.csv"), sqlDataReaderStream); } } }
private string GetList() { var res = new StringBuilder(); var listId = this.Request.QueryString["ListId"]; var itemName = this.Request.QueryString["ItemName"]; var item = new ItemBuilder(itemName, "Playmobil"); var parameters = Request.QueryString.Keys.Cast <string>().ToDictionary(k => k, v => Request.QueryString[v]); parameters = parameters.Where(p => p.Key != "ApplicationUserId" && p.Key != "_" && p.Key != "Action" && p.Key != "ItemName" && p.Key != "ListId").ToDictionary(v => v.Key, v => v.Value); var query = ItemTools.QueryByListId(item, parameters, listId); var instance = CustomerFramework.Load("Playmobil"); return(SqlStream.GetByQuery(query, instance.Config.ConnectionString)); }
private void TestSqlValueSerializerForReadingAndWriting(ISqlValueSerializer p_SqlValueSerializer, int p_BufferSize = 8192) { var cmd = new SqlCommand("SELECT * FROM TestTable", ConnectHelper.CreateConnection()); //ACT with ASSERT using (var sqlDataReaderStream = new SqlStream(cmd, p_SqlValueSerializer)) { var table = sqlDataReaderStream.DataTableWithoutData; Assert.AreEqual(0, table.Rows.Count); new StreamToDataTableRows().ReadStreamToDataTable(sqlDataReaderStream, table, p_SqlValueSerializer, p_BufferSize); Assert.AreEqual(3, table.Rows.Count); Assert.AreEqual(@"Test Tab and NewLine is ok", table.Rows[2]["TestString"], "Failed test string with special chars (same as RowSplitter and ColumnSplitter in Csv format)"); } }
public void SqlStream_ExecuteNonQuery_Enumerates_Entire_Stream() { int actual = 0; int expected = 100; var connection = new Mock <ISqlStreamConnection>(); connection.Setup(c => c.ExecuteNonQuery(It.IsAny <SqlCommand>())).Callback <SqlCommand>((cmd) => { var stream = cmd.Parameters["@stream"].Value as SqlStructuredParameterWrapper <StreamSchema>; Assert.IsNotNull(stream, "@stream parameter cannot be null."); foreach (var item in stream) { actual++; } }); using (SqlStream <StreamSchema> target = new SqlStream <StreamSchema>(connection.Object, SqlStreamBehavior.CloseConnection, 10)) { target.Parameters.Add("@userid", SqlDbType.Int).Value = 1; target.Parameters.AddStructured <StreamSchema>("@stream", "dbo.StreamUDT", target) .Map(src => src.Id, "Id", SqlDbType.Int) .Map(src => src.ProductName, "ProductName", SqlDbType.VarChar, 255) .Map(src => Convert.ToDecimal(src.Price), "Price", SqlDbType.Decimal, 9, 3); for (int i = 0; i < expected; i++) { target.Write(new StreamSchema { Id = i, ProductName = String.Format("Product {0}", i), Price = (i + 1.0) - 0.01 }); //simulate I/O Thread.Sleep(3); } } Assert.AreEqual(expected, actual, "Data wasn't streamed."); }
private string Item_Alumno_GetByCurso() { var instance = CustomerFramework.Load("AMPA"); string res = "[]"; var parameters = new List <SqlParameter> { DataParameter.Input("@CursoId", Convert.ToInt64(this.Request.QueryString["CursoId"])) }; try { res = SqlStream.GetSqlStream("Item_Alumno_GetByCurso", new ReadOnlyCollection <SqlParameter>(parameters), instance.Config.ConnectionString); } catch (Exception ex) { ExceptionManager.Trace(ex, "Item_Alumno_GetByCurso(" + Convert.ToInt64(this.Request.QueryString["CursoId"]) + ")"); } return(res); }
private DataTable SelectDuplicateColumn(DuplicateColumnNameProcess p_DuplicateColumnNameProcess) { using (var conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Database"].ConnectionString)) { conn.Open(); var sql = "SELECT 'A' as ColumnA, 'B' as ColumnA FROM TestTable"; var cmd = new SqlCommand(sql, conn); using (var sqlDataReaderStream = new SqlStream(cmd, new SqlValueSerializerCsvSimple(), p_DuplicateColumnNameProcess)) { Assert.AreEqual(2, sqlDataReaderStream.DataTableWithoutData.Columns.Count); Assert.AreEqual("ColumnA", sqlDataReaderStream.DataTableWithoutData.Columns[0].ColumnName); Assert.AreEqual("ColumnA_1", sqlDataReaderStream.DataTableWithoutData.Columns[1].ColumnName); //must read data to prepared table DataTable table = sqlDataReaderStream.DataTableWithoutData; new StreamToDataTableRows().ReadStreamToDataTable(sqlDataReaderStream, table, new SqlValueSerializerCsvSimple()); Assert.AreEqual("A", table.Rows[0][0].ToString()); return(table); } } }
public void CreateStreamExampleDatabaseAndScripts() { var sqlServerLocator = new SqlServerLocator("localhost", "StreamExample3", "sa", "<password>", "SQLDEV2017"); var configuration = SqlServerDatabaseDefinition.BuildDatabaseConfigurationUsingDefaultsAsNecessary(sqlServerLocator.DatabaseName, @"D:\SQL\"); var createDatabaseOp = new CreateDatabaseOp(configuration, ExistingDatabaseStrategy.Throw); var protocol = new SqlOperationsProtocol(sqlServerLocator); protocol.Execute(createDatabaseOp); var resourceLocatorProtocol = new SingleResourceLocatorProtocols(sqlServerLocator); var configurationTypeRepresentation = typeof(NullJsonSerializationConfiguration).ToRepresentation(); SerializerRepresentation defaultSerializerRepresentation = new SerializerRepresentation( SerializationKind.Json, configurationTypeRepresentation); var defaultSerializationFormat = SerializationFormat.String; var stream = new SqlStream( "Example", TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(3), defaultSerializerRepresentation, defaultSerializationFormat, new JsonSerializerFactory(), resourceLocatorProtocol); stream.Execute(new StandardCreateStreamOp(stream.StreamRepresentation, ExistingStreamStrategy.Skip)); this.testOutputHelper.WriteLine("Created database."); /* * var path = "D:/Temp/Example"; * var connectionString = sqlServerLocator.BuildConnectionString(TimeSpan.FromSeconds(20)); * Scripter.ScriptDatabaseToFilePath(connectionString, path, this.testOutputHelper.WriteLine, false); */ }
public void SqlStream_Integration_Test_With_Output_Parameter() { int actual = 0; int expected = 100; using (SqlStream <StreamSchema> target = new SqlStream <StreamSchema>(new SqlStreamConnection("Server=(local);Database=tempdb;Trusted_Connection=Yes;"), SqlStreamBehavior.CloseConnection, 10)) { target.StoredProcedureName = "dbo.TVPTestProc"; target.Parameters.AddStructured <StreamSchema>("@stream", "dbo.StreamSchema", target) .Map(src => src.Id, "Id", SqlDbType.Int) .Map(src => src.ProductName, "ProductName", SqlDbType.VarChar, 255) .Map(src => Convert.ToDecimal(src.Price), "Price", SqlDbType.Decimal, 9, 3); target.Parameters.Add("@userid", SqlDbType.Int).Value = 1; var output = target.Parameters.Add("@resultCount", SqlDbType.Int); output.Direction = ParameterDirection.InputOutput; output.Value = 0; for (int i = 0; i < expected; i++) { target.Write(new StreamSchema { Id = i, ProductName = String.Format("Product {0}", i), Price = (i + 1.0) - 0.01 }); } // need to wait for Close() or Dispose() before checking output parameters target.Close(); actual = Convert.ToInt32(output.Value); } Assert.AreEqual(expected, actual, "Data wasn't streamed."); }
public void WriteSql(string message) { SqlStream.WriteLine(message); }
private void Initialize(object state) { // NOTE: Called from a ThreadPool thread while (true) { try { var installer = new SqlInstaller(_connectionString, _tableNamePrefix, _configuration.TableCount, _trace); installer.Install(); break; } catch (Exception ex) { // Exception while installing for (var i = 0; i < _configuration.TableCount; i++) { OnError(i, ex); } // Try again in a little bit Thread.Sleep(2000); } } for (var i = 0; i < _configuration.TableCount; i++) { var streamIndex = i; var stream = new SqlStream(streamIndex, _connectionString, tableName: String.Format(CultureInfo.InvariantCulture, "{0}_{1}", _tableNamePrefix, streamIndex), open: () => Open(streamIndex), onReceived: OnReceived, onError: ex => OnError(streamIndex, ex), traceSource: _trace, dbProviderFactory: _dbProviderFactory); _streams.Add(stream); StartStream(streamIndex); } }
private void Initialize(object state) { // NOTE: Called from a ThreadPool thread _trace.TraceInformation("SQL message bus initializing, TableCount={0}", _configuration.TableCount); while (true) { try { var installer = new SqlInstaller(_connectionString, _tableNamePrefix, _configuration.TableCount, _trace); installer.Install(); break; } catch (Exception ex) { // Exception while installing for (var i = 0; i < _configuration.TableCount; i++) { OnError(i, ex); } _trace.TraceError("Error trying to install SQL server objects, trying again in 2 seconds: {0}", ex); // Try again in a little bit Thread.Sleep(2000); } } for (var i = 0; i < _configuration.TableCount; i++) { var streamIndex = i; var tableName = String.Format(CultureInfo.InvariantCulture, "{0}_{1}", _tableNamePrefix, streamIndex); var stream = new SqlStream(streamIndex, _connectionString, tableName, _trace, _dbProviderFactory); stream.Queried += () => Open(streamIndex); stream.Faulted += (ex) => OnError(streamIndex, ex); stream.Received += (id, messages) => OnReceived(streamIndex, id, messages); _streams.Add(stream); StartReceiving(streamIndex); } }
/// <summary> /// Persists the specified stream of data in the queue. /// </summary> /// <param name="data">The stream containing the data to be persisted.</param> /// <returns>A data transfer object carrying the details of the persisted queue item.</returns> public PersistenceQueueItemInfo Enqueue(Stream data) { Guard.ArgumentNotNull(data, "data"); Guard.ArgumentNotNullOrEmptyString(this.dbConnectionString, "dbConnectionString"); var callToken = TraceManager.DataAccessComponent.TraceIn(StreamingMode, StreamingDataType); var scopeStartEnqueueMain = TraceManager.DataAccessComponent.TraceStartScope(Resources.ScopeSqlAzurePersistenceQueueEnqueueMain, callToken); try { PersistenceQueueItemInfo queueItemInfo = null; Guid txGuid = default(Guid); using (var txScope = new TransactionScope(TransactionScopeOption.RequiresNew, TimeSpan.MaxValue)) using (var dbConnection = new ReliableSqlConnection(this.dbConnectionString, this.connectionRetryPolicy, this.commandRetryPolicy)) { if (StreamingDataType == StreamingDataType.Raw) { var scopeStartExecuteQuery = TraceManager.DataAccessComponent.TraceStartScope(Resources.ScopeSqlAzurePersistenceQueueExecuteCommand, callToken); using (IDbCommand newItemCommand = CustomSqlCommandFactory.SqlAzurePersistenceQueue.CreateNewCommand(dbConnection)) { TraceManager.DataAccessComponent.TraceCommand(newItemCommand); txGuid = dbConnection.ExecuteCommand <Guid>(newItemCommand); using (IDbCommand readDataCommand = CustomSqlCommandFactory.SqlAzurePersistenceQueue.CreateQueueItemReadCommand(dbConnection, txGuid)) using (IDbCommand writeDataCommand = CustomSqlCommandFactory.SqlAzurePersistenceQueue.CreateQueueItemWriteCommand(dbConnection, txGuid)) using (IDbCommand getDataSizeCommand = CustomSqlCommandFactory.SqlAzurePersistenceQueue.CreateQueueItemGetSizeCommand(dbConnection, txGuid)) using (SqlStream sqlStream = new SqlStream(dbConnection, readDataCommand as SqlCommand, writeDataCommand as SqlCommand, getDataSizeCommand as SqlCommand)) { BinaryReader dataReader = new BinaryReader(data); byte[] buffer = new byte[this.initialBufferSize]; int bytesRead = 0; do { var scopeStartBufferRead = TraceManager.DataAccessComponent.TraceStartScope(Resources.ScopeSqlAzurePersistenceQueueBufferedReadBytes, callToken); bytesRead = dataReader.ReadBuffered(buffer, 0, this.initialBufferSize); TraceManager.DataAccessComponent.TraceEndScope(Resources.ScopeSqlAzurePersistenceQueueBufferedReadBytes, scopeStartBufferRead, callToken); if (bytesRead > 0) { TraceManager.DataAccessComponent.TraceInfo(TraceLogMessages.SqlStreamWriteOperationDetails, bytesRead); var scopeStartSqlWriteData = TraceManager.DataAccessComponent.TraceStartScope(Resources.ScopeSqlAzurePersistenceQueueWriteData, callToken); sqlStream.Write(buffer, 0, bytesRead); TraceManager.DataAccessComponent.TraceEndScope(Resources.ScopeSqlAzurePersistenceQueueWriteData, scopeStartSqlWriteData, callToken); } }while (bytesRead > 0); } } using (IDbCommand enqueueCommand = CustomSqlCommandFactory.SqlAzurePersistenceQueue.CreateEnqueueCommand(dbConnection, txGuid)) { TraceManager.DataAccessComponent.TraceCommand(enqueueCommand); dbConnection.ExecuteCommand(enqueueCommand); SqlCommandView <EnqueueCommandInspector> enqueueCommandView = new SqlCommandView <EnqueueCommandInspector>(enqueueCommand); queueItemInfo = new PersistenceQueueItemInfo(txGuid, enqueueCommandView.Inspector.QueueItemSize, enqueueCommandView.Inspector.QueueItemType); } txScope.Complete(); TraceManager.DataAccessComponent.TraceEndScope(Resources.ScopeSqlAzurePersistenceQueueExecuteCommand, scopeStartExecuteQuery, callToken); } return(queueItemInfo); } } catch (Exception ex) { TraceManager.DataAccessComponent.TraceError(ex, callToken); throw; } finally { TraceManager.DataAccessComponent.TraceEndScope(Resources.ScopeSqlAzurePersistenceQueueEnqueueMain, scopeStartEnqueueMain, callToken); TraceManager.DataAccessComponent.TraceOut(callToken); } }