1 //------------------------------------------------------------------------------
2 // <copyright file="ByteStorage.cs" company="Microsoft">
3 // Copyright (c) Microsoft Corporation. All rights reserved.
5 // <owner current="true" primary="true">Microsoft</owner>
6 // <owner current="true" primary="false">Microsoft</owner>
7 // <owner current="false" primary="false">Microsoft</owner>
8 //------------------------------------------------------------------------------
10 namespace System.Data.Common {
13 using System.Data.SqlTypes;
14 using System.Collections;
16 internal sealed class ByteStorage : DataStorage {
18 private const Byte defaultValue = 0;
20 private Byte[] values;
22 internal ByteStorage(DataColumn column)
23 : base(column, typeof(Byte), defaultValue, StorageType.Byte) {
26 override public Object Aggregate(int[] records, AggregateType kind) {
30 case AggregateType.Sum:
31 UInt64 sum = defaultValue;
32 foreach (int record in records) {
35 checked { sum += values[record];}
43 case AggregateType.Mean:
44 Int64 meanSum = (Int64)defaultValue;
46 foreach (int record in records) {
49 checked { meanSum += (Int64)values[record];}
55 checked {mean = (Byte)(meanSum / meanCount);}
60 case AggregateType.Var:
61 case AggregateType.StDev:
63 double var = (double)defaultValue;
64 double prec = (double)defaultValue;
65 double dsum = (double)defaultValue;
66 double sqrsum = (double)defaultValue;
68 foreach (int record in records) {
71 dsum += (double)values[record];
72 sqrsum += (double)values[record]*(double)values[record];
77 var = ((double)count * sqrsum - (dsum * dsum));
78 prec = var / (dsum * dsum);
80 // we are dealing with the risk of a cancellation error
81 // double is guaranteed only for 15 digits so a difference
82 // with a result less than 1e-15 should be considered as zero
84 if ((prec < 1e-15) || (var <0))
87 var = var / (count * (count -1));
89 if (kind == AggregateType.StDev) {
90 return Math.Sqrt(var);
96 case AggregateType.Min:
97 Byte min = Byte.MaxValue;
98 for (int i = 0; i < records.Length; i++) {
99 int record = records[i];
102 min=Math.Min(values[record], min);
110 case AggregateType.Max:
111 Byte max = Byte.MinValue;
112 for (int i = 0; i < records.Length; i++) {
113 int record = records[i];
116 max=Math.Max(values[record], max);
124 case AggregateType.First:
125 if (records.Length > 0) {
126 return values[records[0]];
130 case AggregateType.Count:
131 return base.Aggregate(records, kind);
135 catch (OverflowException) {
136 throw ExprException.Overflow(typeof(Byte));
138 throw ExceptionBuilder.AggregateException(kind, DataType);
141 override public int Compare(int recordNo1, int recordNo2) {
142 Byte valueNo1 = values[recordNo1];
143 Byte valueNo2 = values[recordNo2];
145 if (valueNo1 == defaultValue || valueNo2 == defaultValue) {
146 int bitCheck = CompareBits(recordNo1, recordNo2);
150 return valueNo1.CompareTo(valueNo2);
151 //return(valueNo1 - valueNo2); // copied from Byte.CompareTo(Byte)
154 public override int CompareValueTo(int recordNo, object value) {
155 System.Diagnostics.Debug.Assert(0 <= recordNo, "Invalid record");
156 System.Diagnostics.Debug.Assert(null != value, "null value");
158 if (NullValue == value) {
159 if (IsNull(recordNo)) {
165 Byte valueNo1 = values[recordNo];
166 if ((defaultValue == valueNo1) && IsNull(recordNo)) {
169 return valueNo1.CompareTo((Byte)value);
170 //return(valueNo1 - valueNo2); // copied from Byte.CompareTo(Byte)
173 public override object ConvertValue(object value) {
174 if (NullValue != value) {
176 value = ((IConvertible)value).ToByte(FormatProvider);
185 override public void Copy(int recordNo1, int recordNo2) {
186 CopyBits(recordNo1, recordNo2);
187 values[recordNo2] = values[recordNo1];
190 override public Object Get(int record) {
191 Byte value = values[record];
192 if (value != defaultValue) {
195 return GetBits(record);
198 override public void Set(int record, Object value) {
199 System.Diagnostics.Debug.Assert(null != value, "null value");
200 if (NullValue == value) {
201 values[record] = defaultValue;
202 SetNullBit(record, true);
205 values[record] = ((IConvertible)value).ToByte(FormatProvider);
206 SetNullBit(record, false);
210 override public void SetCapacity(int capacity) {
211 Byte[] newValues = new Byte[capacity];
212 if (null != values) {
213 Array.Copy(values, 0, newValues, 0, Math.Min(capacity, values.Length));
216 base.SetCapacity(capacity);
219 override public object ConvertXmlToObject(string s) {
220 return XmlConvert.ToByte(s);
223 override public string ConvertObjectToXml(object value) {
224 return XmlConvert.ToString((Byte) value);
227 override protected object GetEmptyStorage(int recordCount) {
228 return new Byte[recordCount];
231 override protected void CopyValue(int record, object store, BitArray nullbits, int storeIndex) {
232 Byte[] typedStore = (Byte[]) store;
233 typedStore[storeIndex] = values[record];
234 nullbits.Set(storeIndex, IsNull(record));
237 override protected void SetStorage(object store, BitArray nullbits) {
238 values = (Byte[]) store;
239 SetNullStorage(nullbits);