/// <summary>
/// The default constructor.
/// </summary>
/// <param name="reader">The reader to use to read from the database.</param>
/// <param name="ordinal">The column ordinal to read from.</param>
public OrleansRelationalDownloadStream(DbDataReader reader, int ordinal)
{
this.reader = reader;
this.ordinal = ordinal;
//This return the total length of the column pointed by the ordinal.
totalBytes = reader.GetBytes(ordinal, 0, null, 0, 0);
}
/// <summary>
/// Liest sequenziell den Inhalt eines binären Datenfeldes und gibt ihn als object zurück.
/// </summary>
/// <param name="reader">Der DatenReader.</param>
/// <param name="ordinal">0-basierter Spaltenindex.</param>
/// <returns>Binärer Inhalt des Datenfeldes als Objekttyp.</returns>
/// <remarks>
/// Die Methode ist für sequenzielles Einlesen (CommandBehavior.SequentialAccess) ausgelegt.
/// </remarks>
public static byte[] ReadBlob(DbDataReader reader, int ordinal)
{
byte[] blobContent; // Inhalt des BLOB
int bufferSize = 1024; // Größe des BLOB buffer.
byte[] outByte = new byte[bufferSize]; // Der BLOB byte[] buffer, der mit Hilfe von GetBytes gefüllt wird.
long retval; // Anzahl bytes, welche von GetBytes zurückgegeben wird.
long startIndex = 0; // Startposition der BLOB-Ausgabe.
//if (!reader.IsDBNull(ordinal))
//{
MemoryStream memStream = new MemoryStream();
using (BinaryWriter writer = new BinaryWriter(memStream))
{
// Lese die Bytes und erhalte die Anzahl zurückgegebener Bytes.
retval = reader.GetBytes(ordinal, startIndex, outByte, 0, bufferSize);
// Lese solange zusätzliche Bytes bis der Buffer nicht mehr komplett gefüllt wurde.
while (retval == bufferSize)
{
writer.Write(outByte);
writer.Flush();
// Setze den nächsten start index an das Ende des letzen Buffers und fülle den Buffer erneut.
startIndex += bufferSize;
retval = reader.GetBytes(ordinal, startIndex, outByte, 0, bufferSize);
}
// Schreibe den letzen Bufferinhalt.
//writer.Write(outByte, 0, (int)retval - 1);
writer.Write(outByte, 0, (int)retval);
writer.Flush();
memStream.Position = 0;
blobContent = memStream.ToArray();
}
return blobContent;
}
static int GetBytes(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 6);
System.Data.Common.DbDataReader obj = (System.Data.Common.DbDataReader)ToLua.CheckObject(L, 1, typeof(System.Data.Common.DbDataReader));
int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
long arg1 = LuaDLL.tolua_checkint64(L, 3);
byte[] arg2 = ToLua.CheckByteBuffer(L, 4);
int arg3 = (int)LuaDLL.luaL_checknumber(L, 5);
int arg4 = (int)LuaDLL.luaL_checknumber(L, 6);
long o = obj.GetBytes(arg0, arg1, arg2, arg3, arg4);
LuaDLL.tolua_pushint64(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
private static void SetBytes_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset) {
int length = 0;
// Deal with large values by sending bufferLength of NoLengthLimit (== assume
// CheckXetParameters will ignore requested-length checks in this case)
length = CheckXetParameters(metaData.SqlDbType, metaData.MaxLength, NoLengthLimit /* actual */, 0, NoLengthLimit /* buffer length */, offset, NoLengthLimit /* requested length */ );
// Use fixed chunk size for all cases to avoid inquiring from reader.
int chunkSize = __maxByteChunkSize;
byte[] buffer = new byte[ chunkSize ];
long bytesRead;
long bytesWritten = 1; // prime value to get into write loop
long currentOffset = offset;
long lengthWritten = 0;
while ((length < 0 || lengthWritten < length) &&
0 != (bytesRead = reader.GetBytes(ordinal, currentOffset, buffer, 0, chunkSize)) &&
0 != bytesWritten) {
bytesWritten = setters.SetBytes(sink, ordinal, currentOffset, buffer, 0, checked((int) bytesRead));
sink.ProcessMessagesAndThrow();
checked{ currentOffset += bytesWritten; }
checked{ lengthWritten += bytesWritten; }
}
// Make sure to trim any left-over data (remember to trim at end of offset, not just the amount written
setters.SetBytesLength(sink, ordinal, currentOffset);
sink.ProcessMessagesAndThrow();
}
private static void SetBytes_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset)
{
long num6;
int num4 = 0;
num4 = CheckXetParameters(metaData.SqlDbType, metaData.MaxLength, -1L, 0L, -1, offset, -1);
int length = 0x1f40;
byte[] buffer = new byte[length];
long num2 = 1L;
long dataOffset = offset;
for (long i = 0L; ((num4 < 0) || (i < num4)) && ((0L != (num6 = reader.GetBytes(ordinal, dataOffset, buffer, 0, length))) && (0L != num2)); i += num2)
{
num2 = setters.SetBytes(sink, ordinal, dataOffset, buffer, 0, (int) num6);
sink.ProcessMessagesAndThrow();
dataOffset += num2;
}
setters.SetBytesLength(sink, ordinal, dataOffset);
sink.ProcessMessagesAndThrow();
}
static int ReadBinaryBlob (DbDataReader reader, int column, ref byte[] buffer)
{
long nread;
// first, get the length of the buffer needed
if ((nread = reader.GetBytes (column, 0, null, 0, buffer.Length)) > buffer.Length)
Array.Resize (ref buffer, (int) nread);
// read the certificate data
return (int) reader.GetBytes (column, 0, buffer, 0, (int) nread);
}
/// <summary>
/// Gets the bytes contained in the column of the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="columnName">Name of the column.</param>
/// <returns></returns>
public static byte[] GetBytes(DbDataReader reader, string columnName)
{
const int CHUNK_SIZE = 2 * 1024;
byte[] buffer = new byte[CHUNK_SIZE];
long bytesRead;
long fieldOffset = 0;
int col = reader.GetOrdinal(columnName);
using (MemoryStream stream = new MemoryStream())
{
while ((bytesRead = reader.GetBytes(col, fieldOffset, buffer, 0, buffer.Length)) > 0)
{
byte[] actualRead = new byte[bytesRead];
Buffer.BlockCopy(buffer, 0, actualRead, 0, (int)bytesRead);
stream.Write(actualRead, 0, actualRead.Length);
fieldOffset += bytesRead;
}
return stream.ToArray();
}
}