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);
}
}
