/// <summary>
/// Parses the returned server message to read properties.
/// </summary>
/// <param name="input">The deserializer holding the data form the server message.</param>
internal void ParseHeader(Deserializer input)
{
try
{
// Skip the client executionId: the caller (background network thread) already verified a match and
// we recorded it at the start.
input.Skip(8);
// Check field map for status header parsing.
this._HasFields = (HasFields)input.ReadByte();
// Read the Status (and optional associated message).
this.ServerStatus = (ResponseServerStatus)input.ReadSByte();
if ((this._HasFields & HasFields.Status) == HasFields.Status)
this.ServerStatusString = input.ReadString();
// Read the Application Status (and optional associated message).
this.ServerApplicationStatus = input.ReadSByte();
if ((this._HasFields & HasFields.ApplicationStatus) == HasFields.ApplicationStatus)
this.ServerApplicationStatusString = input.ReadString();
// Track query duration (ms).
this.ExecutionDuration = input.ReadInt32();
// Skip exception data (currently not used and initialized to the same value as the Status string!).
if ((this._HasFields & HasFields.Exception) == HasFields.Exception)
//this.ServerExceptionString = input.ReadString();
input.SkipString();
// Figure out whether to move forward or kill over - note that we don't *really* kill over, but simply
// report the Exception in the response's Exception field - the caller should validate that the
// response is in good status before proceeding to read the results.
switch (this.ServerStatus)
{
case ResponseServerStatus.Success:
break;
case ResponseServerStatus.UserAbort:
this.Exception = new VoltAbortException(
Resources.RequestAborted
, this.Status
, this.ServerStatusString
);
break;
case ResponseServerStatus.GracefulFailure:
this.Exception = new VoltRequestFailureException(
Resources.RequestFailure
, this.Status
, this.ServerStatusString
);
break;
case ResponseServerStatus.UnexpectedFailure:
this.Exception = new VoltCriticalRequestFailureException(
Resources.RequestFailure
, this.Status
, this.ServerStatusString
);
break;
default:
this.Exception = new VoltCriticalRequestFailureException(
Resources.ServerFailure
, this.Status
, this.ServerStatusString
);
break;
}
}
catch (Exception x)
{
this.Exception = new VoltSerializationException(Resources.ResponseDeserializationFailure, x);
}
}
/// <summary>
/// Returns a straight data array (boxed) of the requested data type from a single-column Table.
/// </summary>
/// <param name="input">The deserializer hoding the response data.</param>
/// <param name="TResult">The desired output data type of the array elements.</param>
/// <returns>A boxed array of elements of the requested data type.</returns>
internal static object FromSingleColumn(Deserializer input, Type TResult)
{
// Skip table length, metadata length, status, get column count.
short columnCount = input.Skip(9).ReadInt16();
// Validate there is indeed only one column.
if (columnCount != 1)
{
throw new VoltInvalidDataException(Resources.InvalidColumnCount, columnCount);
}
// Read column data type.
DBType columnType = (DBType)input.ReadSByte();
// Validate the data type matches the .NET casting request.
if (VoltType.ToDBType(TResult) != columnType)
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, columnType.ToString()
, TResult.ToString()
);
}
// Skip column name, get Row count.
int rowCount = input.SkipString().ReadInt32();
// Load data.
switch (VoltType.ToNetType(TResult))
{
case VoltType.NetType.Byte:
byte[] dataByte = new byte[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataByte[r] = input.Skip(4).ReadByte();
}
return(dataByte);
case VoltType.NetType.ByteN:
byte?[] dataByteN = new byte?[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataByteN[r] = input.Skip(4).ReadByteN();
}
return(dataByteN);
case VoltType.NetType.SByte:
sbyte[] dataSByte = new sbyte[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataSByte[r] = input.Skip(4).ReadSByte();
}
return(dataSByte);
case VoltType.NetType.SByteN:
sbyte?[] dataSByteN = new sbyte?[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataSByteN[r] = input.Skip(4).ReadSByteN();
}
return(dataSByteN);
case VoltType.NetType.Int16:
short[] dataInt16 = new short[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataInt16[r] = input.Skip(4).ReadInt16();
}
return(dataInt16);
case VoltType.NetType.Int16N:
short?[] dataInt16N = new short?[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataInt16N[r] = input.Skip(4).ReadInt16N();
}
return(dataInt16N);
case VoltType.NetType.Int32:
int[] dataInt32 = new int[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataInt32[r] = input.Skip(4).ReadInt32();
}
return(dataInt32);
case VoltType.NetType.Int32N:
int?[] dataInt32N = new int?[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataInt32N[r] = input.Skip(4).ReadInt32N();
}
return(dataInt32N);
case VoltType.NetType.Int64:
long[] dataInt64 = new long[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataInt64[r] = input.Skip(4).ReadInt64();
}
return(dataInt64);
case VoltType.NetType.Int64N:
long?[] dataInt64N = new long?[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataInt64N[r] = input.Skip(4).ReadInt64N();
}
return(dataInt64N);
case VoltType.NetType.Double:
double[] dataDouble = new double[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataDouble[r] = input.Skip(4).ReadDouble();
}
return(dataDouble);
case VoltType.NetType.DoubleN:
double?[] dataDoubleN = new double?[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataDoubleN[r] = input.Skip(4).ReadDoubleN();
}
return(dataDoubleN);
case VoltType.NetType.DateTime:
DateTime[] dataDateTime = new DateTime[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataDateTime[r] = input.Skip(4).ReadDateTime();
}
return(dataDateTime);
case VoltType.NetType.DateTimeN:
DateTime?[] dataDateTimeN = new DateTime?[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataDateTimeN[r] = input.Skip(4).ReadDateTimeN();
}
return(dataDateTimeN);
case VoltType.NetType.String:
string[] dataString = new string[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataString[r] = input.Skip(4).ReadString();
}
return(dataString);
case VoltType.NetType.VoltDecimal:
VoltDecimal[] dataVoltDecimal = new VoltDecimal[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataVoltDecimal[r] = input.Skip(4).ReadVoltDecimal();
}
return(dataVoltDecimal);
case VoltType.NetType.VoltDecimalN:
VoltDecimal?[] dataVoltDecimalN = new VoltDecimal?[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataVoltDecimalN[r] = input.Skip(4).ReadVoltDecimalN();
}
return(dataVoltDecimalN);
case VoltType.NetType.Decimal:
Decimal[] dataDecimal = new Decimal[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataDecimal[r] = input.Skip(4).ReadDecimal();
}
return(dataDecimal);
case VoltType.NetType.DecimalN:
Decimal?[] dataDecimalN = new Decimal?[rowCount];
for (int r = 0; r < rowCount; r++)
{
dataDecimalN[r] = input.Skip(4).ReadDecimalN();
}
return(dataDecimalN);
case VoltType.NetType.ByteArray:
input.Skip(4);
return(input.ReadByteArray());
default:
throw new VoltUnsupportedTypeException(Resources.UnsupportedParameterNETType, TResult.ToString());
}
}
/// <summary>
/// Parses the returned server message to read properties.
/// </summary>
/// <param name="input">The deserializer holding the data form the server message.</param>
internal void ParseHeader(Deserializer input)
{
try
{
// Skip the client executionId: the caller (background network thread) already verified a match and
// we recorded it at the start.
input.Skip(8);
// Check field map for status header parsing.
this._HasFields = (HasFields)input.ReadByte();
// Read the Status (and optional associated message).
this.ServerStatus = (ResponseServerStatus)input.ReadSByte();
if ((this._HasFields & HasFields.Status) == HasFields.Status)
{
this.ServerStatusString = input.ReadString();
}
// Read the Application Status (and optional associated message).
this.ServerApplicationStatus = input.ReadSByte();
if ((this._HasFields & HasFields.ApplicationStatus) == HasFields.ApplicationStatus)
{
this.ServerApplicationStatusString = input.ReadString();
}
// Track query duration (ms).
this.ExecutionDuration = input.ReadInt32();
// Skip exception data (currently not used and initialized to the same value as the Status string!).
if ((this._HasFields & HasFields.Exception) == HasFields.Exception)
{
//this.ServerExceptionString = input.ReadString();
input.SkipString();
}
// Figure out whether to move forward or kill over - note that we don't *really* kill over, but simply
// report the Exception in the response's Exception field - the caller should validate that the
// response is in good status before proceeding to read the results.
switch (this.ServerStatus)
{
case ResponseServerStatus.Success:
break;
case ResponseServerStatus.UserAbort:
this.Exception = new VoltAbortException(
Resources.RequestAborted
, this.Status
, this.ServerStatusString
);
break;
case ResponseServerStatus.GracefulFailure:
this.Exception = new VoltRequestFailureException(
Resources.RequestFailure
, this.Status
, this.ServerStatusString
);
break;
case ResponseServerStatus.UnexpectedFailure:
this.Exception = new VoltCriticalRequestFailureException(
Resources.RequestFailure
, this.Status
, this.ServerStatusString
);
break;
default:
this.Exception = new VoltCriticalRequestFailureException(
Resources.ServerFailure
, this.Status
, this.ServerStatusString
);
break;
}
}
catch (Exception x)
{
this.Exception = new VoltSerializationException(Resources.ResponseDeserializationFailure, x);
}
}
/// <summary>
/// Returns a single value (strongly-type) of the requested data type from a single-row/single-column Table.
/// </summary>
/// <typeparam name="TResult">The desired output data type of the returned value.</typeparam>
/// <param name="input">The deserializer hoding the response data.</param>
/// <returns>The single cell contained in the table read.</returns>
internal static TResult FromSingleValue <TResult>(Deserializer input)
{
// Skip basic metadata and get Column Count.
short columnCount = input.Skip(9).ReadInt16();
// Read column data type.
DBType columnType = (DBType)input.ReadSByte();
// Validate the data type matches the .NET casting request
if (VoltType.ToDBType(typeof(TResult)) != columnType)
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, columnType.ToString()
, typeof(TResult).ToString()
);
}
// Skip column name and get Row count.
int rowCount = input.SkipString().ReadInt32();
// Validate there is indeed only one column and row.
if ((columnCount != 1) || (rowCount != 1))
{
throw new VoltInvalidDataException(Resources.InvalidRowAndColumnCount, rowCount, columnCount);
}
// Load data (skip row length and load first value) - unfortunately, we do have to box this.
switch (VoltType.ToNetType(typeof(TResult)))
{
case VoltType.NetType.Byte:
return((TResult)(object)input.Skip(4).ReadByte());
case VoltType.NetType.ByteN:
return((TResult)(object)input.Skip(4).ReadByteN());
case VoltType.NetType.SByte:
return((TResult)(object)input.Skip(4).ReadSByte());
case VoltType.NetType.SByteN:
return((TResult)(object)input.Skip(4).ReadSByteN());
case VoltType.NetType.Int16:
return((TResult)(object)input.Skip(4).ReadInt16());
case VoltType.NetType.Int16N:
return((TResult)(object)input.Skip(4).ReadInt16N());
case VoltType.NetType.Int32:
return((TResult)(object)input.Skip(4).ReadInt32());
case VoltType.NetType.Int32N:
return((TResult)(object)input.Skip(4).ReadInt32N());
case VoltType.NetType.Int64:
return((TResult)(object)input.Skip(4).ReadInt64());
case VoltType.NetType.Int64N:
return((TResult)(object)input.Skip(4).ReadInt64N());
case VoltType.NetType.Double:
return((TResult)(object)input.Skip(4).ReadDouble());
case VoltType.NetType.DoubleN:
return((TResult)(object)input.Skip(4).ReadDoubleN());
case VoltType.NetType.DateTime:
return((TResult)(object)input.Skip(4).ReadDateTime());
case VoltType.NetType.DateTimeN:
return((TResult)(object)input.Skip(4).ReadDateTimeN());
case VoltType.NetType.String:
return((TResult)(object)input.Skip(4).ReadString());
case VoltType.NetType.VoltDecimal:
return((TResult)(object)input.Skip(4).ReadVoltDecimal());
case VoltType.NetType.VoltDecimalN:
return((TResult)(object)input.Skip(4).ReadVoltDecimalN());
case VoltType.NetType.Decimal:
return((TResult)(object)input.Skip(4).ReadDecimal());
case VoltType.NetType.DecimalN:
return((TResult)(object)input.Skip(4).ReadDecimalN());
default:
throw new VoltUnsupportedTypeException(
Resources.UnsupportedParameterNETType
, typeof(TResult).ToString()
);
}
}