private void StartBLOB(uint lenExpected)
{
m_Blob.SetSize(0);
if (lenExpected > m_Blob.MaxBufferSize)
{
m_Blob.Realloc(lenExpected);
}
m_Blob.Push(UQueue.IntenalBuffer, UQueue.HeadPosition, UQueue.GetSize());
UQueue.SetSize(0);
}
public static void BatchMessage(ushort idMessage, byte[] message, uint len, CUQueue q)
{
if (message == null)
{
message = new byte[0];
len = 0;
}
else if (len > message.Length)
{
len = (uint)message.Length;
}
if (q.GetSize() == 0)
{
uint count = 1;
q.Save(count);
}
else
{
unsafe
{
fixed (byte* p = q.IntenalBuffer)
{
uint* pN = (uint*)p;
*pN += 1;
}
}
}
q.Save(idMessage).Save(len);
q.Push(message, len);
}
private bool PushText(string text)
{
using (CScopeUQueue sb = new CScopeUQueue())
{
CUQueue q = sb.UQueue;
q.Push(text);
return(PushBlob(q.IntenalBuffer, q.GetSize(), (ushort)tagVariantDataType.sdVT_BSTR));
}
}
public virtual bool Enqueue(byte[] key, ushort idMessage, CUQueue buffer, DEnqueue e, DDiscarded discarded)
{
CUQueue sb = CScopeUQueue.Lock();
sb.Save(key).Save(idMessage);
if (buffer != null)
{
sb.Push(buffer.IntenalBuffer, buffer.HeadPosition, buffer.Size);
}
bool ok = SendRequest(idEnqueue, sb, GetRH(e), discarded, (DOnExceptionFromServer)null);
CScopeUQueue.Unlock(sb);
return(ok);
}
protected override void OnResultReturned(ushort reqId, CUQueue mc)
{
switch (reqId)
{
case DB_CONSTS.idRowsetHeader:
{
m_Blob.SetSize(0);
if (m_Blob.MaxBufferSize > ONE_MEGA_BYTES)
{
m_Blob.Realloc(ONE_MEGA_BYTES);
}
CDBColumnInfoArray vColInfo;
mc.Load(out vColInfo).Load(out m_indexRowset);
KeyValuePair <DRowsetHeader, DRows> p = new KeyValuePair <DRowsetHeader, DRows>();
lock (m_csCache)
{
m_vData.Clear();
if (m_mapRowset.ContainsKey(m_indexRowset))
{
p = m_mapRowset[m_indexRowset];
}
}
if (p.Key != null)
{
p.Key.Invoke(vColInfo);
}
}
break;
case DB_CONSTS.idBeginRows:
m_Blob.SetSize(0);
m_vData.Clear();
break;
case DB_CONSTS.idTransferring:
while (mc.GetSize() > 0)
{
object vt;
mc.Load(out vt);
m_vData.Add(vt);
}
break;
case DB_CONSTS.idEndRows:
if (mc.GetSize() > 0 || m_vData.Count > 0)
{
object vt;
while (mc.GetSize() > 0)
{
mc.Load(out vt);
m_vData.Add(vt);
}
DRows row = null;
lock (m_csCache)
{
if (m_mapRowset.ContainsKey(m_indexRowset))
{
row = m_mapRowset[m_indexRowset].Value;
}
}
if (row != null)
{
row.Invoke(m_vData);
}
}
m_vData.Clear();
break;
case DB_CONSTS.idStartBLOB:
{
m_Blob.SetSize(0);
uint len;
mc.Load(out len);
if (len != uint.MaxValue && len > m_Blob.MaxBufferSize)
{
m_Blob.Realloc(len);
}
m_Blob.Push(mc.IntenalBuffer, mc.HeadPosition, mc.GetSize());
mc.SetSize(0);
}
break;
case DB_CONSTS.idChunk:
m_Blob.Push(mc.IntenalBuffer, mc.GetSize());
mc.SetSize(0);
break;
case DB_CONSTS.idEndBLOB:
if (mc.GetSize() > 0 || m_Blob.GetSize() > 0)
{
m_Blob.Push(mc.IntenalBuffer, mc.GetSize());
mc.SetSize(0);
unsafe
{
fixed(byte *p = m_Blob.IntenalBuffer)
{
uint *len = (uint *)(p + m_Blob.HeadPosition + sizeof(ushort));
if (*len >= BLOB_LENGTH_NOT_AVAILABLE)
{
//length should be reset if BLOB length not available from server side at beginning
*len = (m_Blob.GetSize() - sizeof(ushort) - sizeof(uint));
}
}
}
object vt;
m_Blob.Load(out vt);
m_vData.Add(vt);
}
break;
default:
base.OnResultReturned(reqId, mc);
break;
}
}
internal void Push(CUQueue UQueue, DataRow dr)
{
int n;
bool bNull;
if (dr == null)
throw new ArgumentNullException("Datarow object can't be null");
if (m_dts == null)
throw new ArgumentNullException("DataTable header is not serialized yet");
if (m_dts.Length != dr.ItemArray.Length)
throw new InvalidOperationException("The size of the input data type array does not match the size of data row");
byte b = 0;
byte bOne = 1;
m_qBit.SetSize(0);
m_qTemp.SetSize(0);
bool bDelete = (dr.RowState == DataRowState.Deleted);
if (bDelete)
dr.RejectChanges();
object[] data = dr.ItemArray;
int nLen = m_dts.Length;
for (n = 0; n < nLen; n++)
{
object myData = data[n];
bNull = (myData == null || myData.Equals(DBNull.Value));
if (bNull)
{
b += (byte)(bOne << (byte)(n % 8));
}
if ((n % 8) == 7)
{
m_qBit.Save(b);
b = 0;
}
if (bNull)
continue;
switch (m_dts[n])
{
case tagDataTypeSupported.dtBoolean:
m_qTemp.Save((bool)myData);
break;
case tagDataTypeSupported.dtByte:
m_qTemp.Save((byte)myData);
break;
case tagDataTypeSupported.dtChar:
m_qTemp.Save((char)myData);
break;
case tagDataTypeSupported.dtDateTime:
m_qTemp.Save((DateTime)myData);
break;
case tagDataTypeSupported.dtDecimal:
m_qTemp.Save((decimal)myData);
break;
case tagDataTypeSupported.dtDouble:
m_qTemp.Save((double)myData);
break;
case tagDataTypeSupported.dtFloat:
m_qTemp.Save((float)myData);
break;
case tagDataTypeSupported.dtGuid:
m_qTemp.Save((Guid)myData);
break;
case tagDataTypeSupported.dtUInt16:
m_qTemp.Save((ushort)myData);
break;
case tagDataTypeSupported.dtUInt32:
m_qTemp.Save((uint)myData);
break;
case tagDataTypeSupported.dtUInt64:
m_qTemp.Save((ulong)myData);
break;
case tagDataTypeSupported.dtInt16:
m_qTemp.Save((short)myData);
break;
case tagDataTypeSupported.dtInt32:
m_qTemp.Save((int)myData);
break;
case tagDataTypeSupported.dtInt64:
m_qTemp.Save((long)myData);
break;
case tagDataTypeSupported.dtString:
m_qTemp.Save((string)myData);
break;
case tagDataTypeSupported.dtValue:
case tagDataTypeSupported.dtValues:
case tagDataTypeSupported.dtChars:
case tagDataTypeSupported.dtBytes:
case tagDataTypeSupported.dtTimeSpan:
m_qTemp.Save(myData, false, false);
break;
case tagDataTypeSupported.dtUDT:
m_qTemp.Save(myData.ToString());
break;
default:
throw new InvalidOperationException("Unsupported data type for serialization");
}
}
if ((n % 8) != 0)
m_qBit.Save(b);
UQueue.Push(m_qBit.m_bytes, m_qBit.GetSize());
UQueue.Push(m_qTemp.m_bytes, m_qTemp.GetSize());
if (bDelete)
dr.Delete();
UQueue.Save((byte)dr.RowState);
UQueue.Save(dr.HasErrors);
if (dr.HasErrors)
UQueue.Save(dr.RowError);
}
internal void Push(CUQueue UQueue, IDataReader dr)
{
int n;
bool bNull;
if (dr == null)
throw new ArgumentNullException("Datarow object can't be null");
if (m_dts == null)
throw new ArgumentNullException("DataTable header is not serialized yet");
if (m_dts.Length != dr.FieldCount)
throw new InvalidOperationException("The size of the input data type array does not match the size of data row");
byte b = 0;
byte bOne = 1;
m_qBit.SetSize(0);
m_qTemp.SetSize(0);
int nLen = m_dts.Length;
for (n = 0; n < nLen; n++)
{
bNull = dr.IsDBNull(n);
if (bNull)
{
b += (byte)(bOne << (byte)(n % 8));
}
if ((n % 8) == 7)
{
m_qBit.Save(b);
b = 0;
}
if (bNull)
continue;
switch (m_dts[n])
{
case tagDataTypeSupported.dtBoolean:
m_qTemp.Save(dr.GetBoolean(n));
break;
case tagDataTypeSupported.dtByte:
m_qTemp.Save(dr.GetByte(n));
break;
case tagDataTypeSupported.dtChar:
m_qTemp.Save(dr.GetChar(n));
break;
case tagDataTypeSupported.dtDateTime:
m_qTemp.Save(dr.GetDateTime(n));
break;
case tagDataTypeSupported.dtDecimal:
m_qTemp.Save(dr.GetDecimal(n));
break;
case tagDataTypeSupported.dtDouble:
m_qTemp.Save(dr.GetDouble(n));
break;
case tagDataTypeSupported.dtFloat:
m_qTemp.Save(dr.GetFloat(n));
break;
case tagDataTypeSupported.dtGuid:
m_qTemp.Save(dr.GetGuid(n));
break;
case tagDataTypeSupported.dtInt16:
m_qTemp.Save(dr.GetInt16(n));
break;
case tagDataTypeSupported.dtInt32:
m_qTemp.Save(dr.GetInt32(n));
break;
case tagDataTypeSupported.dtInt64:
m_qTemp.Save(dr.GetInt64(n));
break;
case tagDataTypeSupported.dtString:
{
string str = dr.GetString(n);
m_qTemp.Save(str);
}
break;
case tagDataTypeSupported.dtBytes:
{
uint nBytes = (uint)dr.GetBytes(n, (long)0, null, 0, 0);
if (m_Buffer == null || nBytes > m_Buffer.Length)
m_Buffer = new byte[nBytes + 1024];
dr.GetBytes(n, (long)0, m_Buffer, 0, (int)nBytes);
m_qTemp.Save(nBytes);
m_qTemp.Push(m_Buffer, nBytes);
}
break;
case tagDataTypeSupported.dtUInt64:
case tagDataTypeSupported.dtUInt32:
case tagDataTypeSupported.dtUInt16:
case tagDataTypeSupported.dtValue:
case tagDataTypeSupported.dtValues:
case tagDataTypeSupported.dtTimeSpan:
{
object obj = dr.GetValue(n);
m_qTemp.Save(obj, false, false);
}
break;
case tagDataTypeSupported.dtUDT:
{
object obj = dr.GetValue(n);
m_qTemp.Save(obj.ToString());
}
break;
default:
throw new InvalidOperationException("Unsupported data type for serialization");
}
}
if ((n % 8) != 0)
m_qBit.Save(b);
UQueue.Push(m_qBit.m_bytes, m_qBit.GetSize());
UQueue.Push(m_qTemp.m_bytes, m_qTemp.GetSize());
}
