public override ValueTask <byte[]> GetSliceAsync(int sliceLength, CancellationToken cancellationToken = default)
{
ClearStatusVector();
var dbHandle = _db.HandlePtr;
var trHandle = _transaction.HandlePtr;
var arrayDesc = ArrayDescMarshaler.MarshalManagedToNative(Descriptor);
var buffer = new byte[sliceLength];
_db.FbClient.isc_array_get_slice(
_statusVector,
ref dbHandle,
ref trHandle,
ref _handle,
arrayDesc,
buffer,
ref sliceLength);
ArrayDescMarshaler.CleanUpNativeData(ref arrayDesc);
_db.ProcessStatusVector(_statusVector);
return(ValueTask2.FromResult(buffer));
}
public override ValueTask <List <object> > GetDatabaseInfoAsync(byte[] items, int bufferLength, CancellationToken cancellationToken = default)
{
var buffer = new byte[bufferLength];
DatabaseInfo(items, buffer, buffer.Length);
return(ValueTask2.FromResult(IscHelper.ParseDatabaseInfo(buffer)));
}
static ValueTask <int> ReadChunkAsync(Socket socket, byte[] buffer, int offset, int toRead,
CancellationToken token)
{
if (socket.Available == 0)
{
return(DoReadChunkAsync(socket, buffer, offset, toRead, token));
}
int received = socket.Receive(buffer, offset, toRead, SocketFlags.None);
return(ValueTask2.FromResult(received));
}
public static ValueTask <bool> ReadChunkAsync(this TcpClient client, byte[] buffer, int toRead,
CancellationToken token)
{
var socket = client.Client;
if (socket.Available < toRead)
{
return(DoReadChunkAsync(socket, buffer, toRead, token));
}
int received = socket.Receive(buffer, 0, toRead, SocketFlags.None);
return(ValueTask2.FromResult(received == toRead));
}
protected override ValueTask <byte[]> GetSqlInfoAsync(byte[] items, int bufferLength, CancellationToken cancellationToken = default)
{
ClearStatusVector();
var buffer = new byte[bufferLength];
_db.FbClient.isc_dsql_sql_info(
_statusVector,
ref _handle,
(short)items.Length,
items,
(short)bufferLength,
buffer);
_db.ProcessStatusVector(_statusVector);
return(ValueTask2.FromResult(buffer));
}
public override ValueTask <ArrayBase> CreateArrayAsync(ArrayDesc descriptor, CancellationToken cancellationToken = default)
{
var array = new FesArray(descriptor);
return(ValueTask2.FromResult <ArrayBase>(array));
}
protected override ValueTask <Array> DecodeSliceAsync(byte[] slice, CancellationToken cancellationToken = default)
{
Array sliceData = null;
var slicePosition = 0;
var type = 0;
var dbType = DbDataType.Array;
var systemType = GetSystemType();
var charset = _db.Charset;
var lengths = new int[Descriptor.Dimensions];
var lowerBounds = new int[Descriptor.Dimensions];
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);
var tempData = Array.CreateInstance(systemType, sliceData.Length);
type = TypeHelper.GetSqlTypeFromBlrType(Descriptor.DataType);
dbType = TypeHelper.GetDbDataTypeFromBlrType(Descriptor.DataType, 0, Descriptor.Scale);
int itemLength = Descriptor.Length;
for (var i = 0; i < tempData.Length; i++)
{
if (slicePosition >= slice.Length)
{
break;
}
switch (dbType)
{
case DbDataType.Char:
tempData.SetValue(charset.GetString(slice, slicePosition, itemLength), i);
break;
case DbDataType.VarChar:
{
var index = slicePosition;
var count = 0;
while (slice[index++] != 0)
{
count++;
}
tempData.SetValue(charset.GetString(slice, slicePosition, count), i);
slicePosition += 2;
}
break;
case DbDataType.SmallInt:
tempData.SetValue(BitConverter.ToInt16(slice, slicePosition), i);
break;
case DbDataType.Integer:
tempData.SetValue(BitConverter.ToInt32(slice, slicePosition), i);
break;
case DbDataType.BigInt:
tempData.SetValue(BitConverter.ToInt64(slice, slicePosition), i);
break;
case DbDataType.Decimal:
case DbDataType.Numeric:
{
object evalue = null;
switch (type)
{
case IscCodes.SQL_SHORT:
evalue = BitConverter.ToInt16(slice, slicePosition);
break;
case IscCodes.SQL_LONG:
evalue = BitConverter.ToInt32(slice, slicePosition);
break;
case IscCodes.SQL_QUAD:
case IscCodes.SQL_INT64:
evalue = BitConverter.ToInt64(slice, slicePosition);
break;
}
var dvalue = TypeDecoder.DecodeDecimal(evalue, Descriptor.Scale, type);
tempData.SetValue(dvalue, i);
}
break;
case DbDataType.Double:
tempData.SetValue(BitConverter.ToDouble(slice, slicePosition), i);
break;
case DbDataType.Float:
tempData.SetValue(BitConverter.ToSingle(slice, slicePosition), i);
break;
case DbDataType.Date:
{
var idate = BitConverter.ToInt32(slice, slicePosition);
var date = TypeDecoder.DecodeDate(idate);
tempData.SetValue(date, i);
}
break;
case DbDataType.Time:
{
var itime = BitConverter.ToInt32(slice, slicePosition);
var time = TypeDecoder.DecodeTime(itime);
tempData.SetValue(time, i);
}
break;
case DbDataType.TimeStamp:
{
var idate = BitConverter.ToInt32(slice, slicePosition);
var itime = BitConverter.ToInt32(slice, slicePosition + 4);
var date = TypeDecoder.DecodeDate(idate);
var time = TypeDecoder.DecodeTime(itime);
var timestamp = date.Add(time);
tempData.SetValue(timestamp, i);
}
break;
}
slicePosition += itemLength;
}
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(ValueTask2.FromResult(sliceData));
}
