protected virtual byte[] WriteParameters()
{
if (_parameters == null)
{
return(null);
}
using (var ms = new MemoryStream())
{
var xdr = new XdrReaderWriter(ms, _database.Charset);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
try
{
WriteRawParameter(xdr, field);
xdr.Write(field.NullFlag);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
xdr.Flush();
return(ms.ToArray());
}
}
protected virtual async Task <byte[]> WriteParameters(AsyncWrappingCommonArgs async)
{
if (_parameters == null)
{
return(null);
}
using (var ms = new MemoryStream())
{
var xdr = new XdrReaderWriter(new DataProviderStreamWrapper(ms), _database.Charset);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
try
{
await WriteRawParameter(xdr, field, async).ConfigureAwait(false);
await xdr.Write(field.NullFlag, async).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
await xdr.Flush(async).ConfigureAwait(false);
return(ms.ToArray());
}
}
protected override async Task <byte[]> WriteParameters(AsyncWrappingCommonArgs async)
{
if (_parameters == null)
{
return(null);
}
using (var ms = new MemoryStream())
{
try
{
var xdr = new XdrReaderWriter(new DataProviderStreamWrapper(ms), _database.Charset);
var bits = new BitArray(_parameters.Count);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
bits.Set(i, await field.DbValue.IsDBNull(async).ConfigureAwait(false));
}
var buffer = new byte[(int)Math.Ceiling(_parameters.Count / 8d)];
for (var i = 0; i < buffer.Length * 8; i++)
{
var index = i / 8;
// LSB
buffer[index] = (byte)((buffer[index] >> 1) | (bits.Length > i && bits[i] ? 1 << 7 : 0));
}
await xdr.WriteOpaque(buffer, async).ConfigureAwait(false);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
if (await field.DbValue.IsDBNull(async).ConfigureAwait(false))
{
continue;
}
await WriteRawParameter(xdr, field, async).ConfigureAwait(false);
}
await xdr.Flush(async).ConfigureAwait(false);
return(ms.ToArray());
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
}
protected internal override byte[] WriteParameters()
{
if (_parameters == null)
{
return(null);
}
using (var ms = new MemoryStream())
{
try
{
var xdr = new XdrReaderWriter(new DataProviderStreamWrapper(ms), _database.Charset);
var bits = new BitArray(_parameters.Count);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
bits.Set(i, field.DbValue.IsDBNull());
}
var buffer = new byte[(int)Math.Ceiling(_parameters.Count / 8d)];
for (var i = 0; i < buffer.Length * 8; i++)
{
var index = i / 8;
// LSB
buffer[index] = (byte)((buffer[index] >> 1) | (bits.Length > i && bits[i] ? 1 << 7 : 0));
}
xdr.WriteOpaque(buffer);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
if (field.DbValue.IsDBNull())
{
continue;
}
WriteRawParameter(xdr, field);
}
xdr.Flush();
return(ms.ToArray());
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
}
public void Connect()
{
try
{
IPAddress = GetIPAddress(DataSource);
var endPoint = new IPEndPoint(IPAddress, PortNumber);
var socket = new Socket(IPAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, PacketSize);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendBuffer, PacketSize);
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
socket.Connect(endPoint);
_networkStream = new NetworkStream(socket, true);
_firebirdNetworkHandlingWrapper = new FirebirdNetworkHandlingWrapper(new DataProviderStreamWrapper(_networkStream));
Xdr = new XdrReaderWriter(_firebirdNetworkHandlingWrapper, Charset);
}
catch (SocketException ex)
{
throw IscException.ForTypeErrorCodeStrParam(IscCodes.isc_arg_gds, IscCodes.isc_network_error, DataSource, ex);
}
}
private async Task <byte[]> EncodeSliceArray(Array sourceArray, AsyncWrappingCommonArgs async)
{
var dbType = DbDataType.Array;
var charset = _database.Charset;
var subType = (Descriptor.Scale < 0) ? 2 : 0;
var type = 0;
using (var ms = new MemoryStream())
{
var xdr = new XdrReaderWriter(new DataProviderStreamWrapper(ms), _database.Charset);
type = TypeHelper.GetSqlTypeFromBlrType(Descriptor.DataType);
dbType = TypeHelper.GetDbDataTypeFromBlrType(Descriptor.DataType, subType, Descriptor.Scale);
foreach (var source in sourceArray)
{
switch (dbType)
{
case DbDataType.Char:
var buffer = charset.GetBytes(source.ToString());
await xdr.WriteOpaque(buffer, Descriptor.Length, async).ConfigureAwait(false);
break;
case DbDataType.VarChar:
await xdr.Write((string)source, async).ConfigureAwait(false);
break;
case DbDataType.SmallInt:
await xdr.Write((short)source, async).ConfigureAwait(false);
break;
case DbDataType.Integer:
await xdr.Write((int)source, async).ConfigureAwait(false);
break;
case DbDataType.BigInt:
await xdr.Write((long)source, async).ConfigureAwait(false);
break;
case DbDataType.Decimal:
case DbDataType.Numeric:
await xdr.Write((decimal)source, type, Descriptor.Scale, async).ConfigureAwait(false);
break;
case DbDataType.Float:
await xdr.Write((float)source, async).ConfigureAwait(false);
break;
case DbDataType.Double:
await xdr.Write((double)source, async).ConfigureAwait(false);
break;
case DbDataType.Date:
await xdr.WriteDate(Convert.ToDateTime(source, CultureInfo.CurrentCulture.DateTimeFormat), async).ConfigureAwait(false);
break;
case DbDataType.Time:
await xdr.WriteTime((TimeSpan)source, async).ConfigureAwait(false);
break;
case DbDataType.TimeStamp:
await xdr.Write(Convert.ToDateTime(source, CultureInfo.CurrentCulture.DateTimeFormat), async).ConfigureAwait(false);
break;
#warning New datatypes
default:
throw TypeHelper.InvalidDataType((int)dbType);
}
}
await xdr.Flush(async).ConfigureAwait(false);
return(ms.ToArray());
}
}
private async Task <byte[]> ReceiveSliceResponse(ArrayDesc desc, AsyncWrappingCommonArgs async)
{
try
{
var operation = await _database.ReadOperation(async).ConfigureAwait(false);
if (operation == IscCodes.op_slice)
{
var isVariying = false;
var elements = 0;
var length = await _database.Xdr.ReadInt32(async).ConfigureAwait(false);
length = await _database.Xdr.ReadInt32(async).ConfigureAwait(false);
switch (desc.DataType)
{
case IscCodes.blr_text:
case IscCodes.blr_text2:
case IscCodes.blr_cstring:
case IscCodes.blr_cstring2:
elements = length / desc.Length;
length += elements * ((4 - desc.Length) & 3);
break;
case IscCodes.blr_varying:
case IscCodes.blr_varying2:
elements = length / desc.Length;
isVariying = true;
break;
case IscCodes.blr_short:
length = length * desc.Length;
break;
}
if (isVariying)
{
using (var ms = new MemoryStream())
{
var xdr = new XdrReaderWriter(new DataProviderStreamWrapper(ms));
for (var i = 0; i < elements; i++)
{
var buffer = await _database.Xdr.ReadOpaque(await _database.Xdr.ReadInt32(async).ConfigureAwait(false), async).ConfigureAwait(false);
await xdr.WriteBuffer(buffer, buffer.Length, async).ConfigureAwait(false);
}
await xdr.Flush(async).ConfigureAwait(false);
return(ms.ToArray());
}
}
else
{
return(await _database.Xdr.ReadOpaque(length, async).ConfigureAwait(false));
}
}
else
{
await _database.ReadResponse(operation, async).ConfigureAwait(false);
return(null);
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
protected override async Task <Array> DecodeSlice(byte[] slice, AsyncWrappingCommonArgs async)
{
var dbType = DbDataType.Array;
Array sliceData = null;
Array tempData = null;
var systemType = GetSystemType();
var lengths = new int[Descriptor.Dimensions];
var lowerBounds = new int[Descriptor.Dimensions];
var type = 0;
var index = 0;
for (var i = 0; i < Descriptor.Dimensions; i++)
{
lowerBounds[i] = Descriptor.Bounds[i].LowerBound;
lengths[i] = Descriptor.Bounds[i].UpperBound;
if (lowerBounds[i] == 0)
{
lengths[i]++;
}
}
sliceData = Array.CreateInstance(systemType, lengths, lowerBounds);
tempData = Array.CreateInstance(systemType, sliceData.Length);
type = TypeHelper.GetSqlTypeFromBlrType(Descriptor.DataType);
dbType = TypeHelper.GetDbDataTypeFromBlrType(Descriptor.DataType, 0, Descriptor.Scale);
using (var ms = new MemoryStream(slice))
{
var xdr = new XdrReaderWriter(new DataProviderStreamWrapper(ms), _database.Charset);
while (ms.Position < ms.Length)
{
switch (dbType)
{
case DbDataType.Char:
tempData.SetValue(await xdr.ReadString(Descriptor.Length, async).ConfigureAwait(false), index);
break;
case DbDataType.VarChar:
tempData.SetValue(await xdr.ReadString(async).ConfigureAwait(false), index);
break;
case DbDataType.SmallInt:
tempData.SetValue(await xdr.ReadInt16(async).ConfigureAwait(false), index);
break;
case DbDataType.Integer:
tempData.SetValue(await xdr.ReadInt32(async).ConfigureAwait(false), index);
break;
case DbDataType.BigInt:
tempData.SetValue(await xdr.ReadInt64(async).ConfigureAwait(false), index);
break;
case DbDataType.Numeric:
case DbDataType.Decimal:
tempData.SetValue(await xdr.ReadDecimal(type, Descriptor.Scale, async).ConfigureAwait(false), index);
break;
case DbDataType.Float:
tempData.SetValue(await xdr.ReadSingle(async).ConfigureAwait(false), index);
break;
case DbDataType.Double:
tempData.SetValue(await xdr.ReadDouble(async).ConfigureAwait(false), index);
break;
case DbDataType.Date:
tempData.SetValue(await xdr.ReadDate(async).ConfigureAwait(false), index);
break;
case DbDataType.Time:
tempData.SetValue(await xdr.ReadTime(async).ConfigureAwait(false), index);
break;
case DbDataType.TimeStamp:
tempData.SetValue(await xdr.ReadDateTime(async).ConfigureAwait(false), index);
break;
}
index++;
}
if (systemType.GetTypeInfo().IsPrimitive)
{
// For primitive types we can use System.Buffer to copy generated data to destination array
Buffer.BlockCopy(tempData, 0, sliceData, 0, Buffer.ByteLength(tempData));
}
else
{
sliceData = tempData;
}
}
return(sliceData);
}
private byte[] EncodeSliceArray(Array sourceArray)
{
var dbType = DbDataType.Array;
var charset = _database.Charset;
var subType = (Descriptor.Scale < 0) ? 2 : 0;
var type = 0;
using (var ms = new MemoryStream())
{
var xdr = new XdrReaderWriter(ms, _database.Charset);
type = TypeHelper.GetSqlTypeFromBlrType(Descriptor.DataType);
dbType = TypeHelper.GetDbDataTypeFromBlrType(Descriptor.DataType, subType, Descriptor.Scale);
foreach (var source in sourceArray)
{
switch (dbType)
{
case DbDataType.Char:
var buffer = charset.GetBytes(source.ToString());
xdr.WriteOpaque(buffer, Descriptor.Length);
break;
case DbDataType.VarChar:
xdr.Write((string)source);
break;
case DbDataType.SmallInt:
xdr.Write((short)source);
break;
case DbDataType.Integer:
xdr.Write((int)source);
break;
case DbDataType.BigInt:
xdr.Write((long)source);
break;
case DbDataType.Decimal:
case DbDataType.Numeric:
xdr.Write((decimal)source, type, Descriptor.Scale);
break;
case DbDataType.Float:
xdr.Write((float)source);
break;
case DbDataType.Double:
xdr.Write((double)source);
break;
case DbDataType.Date:
xdr.WriteDate(Convert.ToDateTime(source, CultureInfo.CurrentCulture.DateTimeFormat));
break;
case DbDataType.Time:
xdr.WriteTime((TimeSpan)source);
break;
case DbDataType.TimeStamp:
xdr.Write(Convert.ToDateTime(source, CultureInfo.CurrentCulture.DateTimeFormat));
break;
default:
throw TypeHelper.InvalidDataType((int)dbType);
}
}
xdr.Flush();
return(ms.ToArray());
}
}
private byte[] ReceiveSliceResponse(ArrayDesc desc)
{
try
{
var operation = _database.ReadOperation();
if (operation == IscCodes.op_slice)
{
var isVariying = false;
var elements = 0;
var length = _database.Xdr.ReadInt32();
length = _database.Xdr.ReadInt32();
switch (desc.DataType)
{
case IscCodes.blr_text:
case IscCodes.blr_text2:
case IscCodes.blr_cstring:
case IscCodes.blr_cstring2:
elements = length / desc.Length;
length += elements * ((4 - desc.Length) & 3);
break;
case IscCodes.blr_varying:
case IscCodes.blr_varying2:
elements = length / desc.Length;
isVariying = true;
break;
case IscCodes.blr_short:
length = length * desc.Length;
break;
}
if (isVariying)
{
using (var ms = new MemoryStream())
{
var xdr = new XdrReaderWriter(ms);
for (var i = 0; i < elements; i++)
{
var buffer = _database.Xdr.ReadOpaque(_database.Xdr.ReadInt32());
xdr.WriteBuffer(buffer, buffer.Length);
}
xdr.Flush();
return(ms.ToArray());
}
}
else
{
return(_database.Xdr.ReadOpaque(length));
}
}
else
{
_database.ReadResponse(operation);
return(null);
}
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
