/// <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(); } }