Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data/System/Data/SqlClient/SqlSequentialStreamSmi.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Data.Common;
+using Microsoft.SqlServer.Server;
+
+namespace System.Data.SqlClient
+{
+    sealed internal class SqlSequentialStreamSmi : System.IO.Stream
+    {
+        private SmiEventSink_Default _sink;
+        private ITypedGettersV3 _getters;
+        private int _columnIndex;       // The index of out column in the table
+        private long _position;         // Current position in the stream
+        private long _length;           // Total length of the stream
+
+        internal SqlSequentialStreamSmi(SmiEventSink_Default sink, ITypedGettersV3 getters, int columnIndex, long length)
+        {
+            _sink = sink;
+            _getters = getters;
+            _columnIndex = columnIndex;
+            _length = length;
+            _position = 0;
+        }
+
+        public override bool CanRead
+        {
+            get { return ((_sink != null) && (_getters != null)); }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return false; }
+        }
+
+        public override void Flush()
+        { }
+
+        public override long Length
+        {
+            get { throw ADP.NotSupported(); }
+        }
+
+        public override long Position
+        {
+            get { throw ADP.NotSupported(); }
+            set { throw ADP.NotSupported(); }
+        }
+        
+        internal int ColumnIndex
+        {
+            get { return _columnIndex; }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            SqlSequentialStream.ValidateReadParameters(buffer, offset, count);
+            if (!CanRead)
+            {
+                throw ADP.ObjectDisposed(this);
+            }
+
+            try
+            {
+                // Read whichever is less: however much the user asked for, or however much we have
+                // NOTE: It is safe to do this since count <= Int32.MaxValue, therefore the Math.Min should always result in an int
+                int bytesNeeded = (int)Math.Min((long)count, _length - _position);
+                int bytesRead = 0;
+                if (bytesNeeded > 0)
+                {
+                    bytesRead = ValueUtilsSmi.GetBytes_Unchecked(_sink, _getters, _columnIndex, _position, buffer, offset, bytesNeeded);
+                    _position += bytesRead;
+                }
+                return bytesRead;
+            }
+            catch (SqlException ex)
+            {
+                // Stream.Read() can't throw a SqlException - so wrap it in an IOException
+                throw ADP.ErrorReadingFromStream(ex);
+            }
+        }
+        
+        public override long Seek(long offset, IO.SeekOrigin origin)
+        {
+            throw ADP.NotSupported();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw ADP.NotSupported();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw ADP.NotSupported();
+        }
+
+        /// <summary>
+        /// Forces the stream to act as if it was closed (i.e. CanRead=false and Read() throws)
+        /// This does not actually close the stream, read off the rest of the data or dispose this
+        /// </summary>
+        internal void SetClosed()
+        {
+            _sink = null;
+            _getters = null;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                SetClosed();
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}