Esempio n. 1
0
        protected override Array DecodeSlice(byte[] slice)
        {
            DbDataType dbType     = DbDataType.Array;
            Array      sliceData  = null;
            Array      tempData   = null;
            Type       systemType = GetSystemType();

            int[] lengths     = new int[Descriptor.Dimensions];
            int[] lowerBounds = new int[Descriptor.Dimensions];
            int   type        = 0;
            int   index       = 0;

            for (int i = 0; i < Descriptor.Dimensions; i++)
            {
                lowerBounds[i] = Descriptor.Bounds[i].LowerBound;
                lengths[i]     = Descriptor.Bounds[i].UpperBound;

                if (lowerBounds[i] == 0)
                {
                    lengths[i]++;
                }
            }

            sliceData = Array.CreateInstance(systemType, lengths, lowerBounds);
            tempData  = Array.CreateInstance(systemType, sliceData.Length);

            type   = TypeHelper.GetSqlTypeFromBlrType(Descriptor.DataType);
            dbType = TypeHelper.GetDbDataTypeFromBlrType(Descriptor.DataType, 0, Descriptor.Scale);

            using (XdrStream xdr = new XdrStream(slice, _database.Charset))
            {
                while (xdr.Position < xdr.Length)
                {
                    switch (dbType)
                    {
                    case DbDataType.Char:
                        tempData.SetValue(xdr.ReadString(Descriptor.Length), index);
                        break;

                    case DbDataType.VarChar:
                        tempData.SetValue(xdr.ReadString(), index);
                        break;

                    case DbDataType.SmallInt:
                        tempData.SetValue(xdr.ReadInt16(), index);
                        break;

                    case DbDataType.Integer:
                        tempData.SetValue(xdr.ReadInt32(), index);
                        break;

                    case DbDataType.BigInt:
                        tempData.SetValue(xdr.ReadInt64(), index);
                        break;

                    case DbDataType.Numeric:
                    case DbDataType.Decimal:
                        tempData.SetValue(xdr.ReadDecimal(type, Descriptor.Scale), index);
                        break;

                    case DbDataType.Float:
                        tempData.SetValue(xdr.ReadSingle(), index);
                        break;

                    case DbDataType.Double:
                        tempData.SetValue(xdr.ReadDouble(), index);
                        break;

                    case DbDataType.Date:
                        tempData.SetValue(xdr.ReadDate(), index);
                        break;

                    case DbDataType.Time:
                        tempData.SetValue(xdr.ReadTime(), index);
                        break;

                    case DbDataType.TimeStamp:
                        tempData.SetValue(xdr.ReadDateTime(), index);
                        break;
                    }

                    index++;
                }

#if NET40
                if (systemType.IsPrimitive)
#else
                if (systemType.GetTypeInfo().IsPrimitive)
#endif
                {
                    // For primitive types we can use System.Buffer	to copy	generated data to destination array
                    Buffer.BlockCopy(tempData, 0, sliceData, 0, Buffer.ByteLength(tempData));
                }
                else
                {
                    sliceData = tempData;
                }
            }

            return(sliceData);
        }
Esempio n. 2
0
        protected override System.Array DecodeSlice(byte[] slice)
        {
            DbDataType dbType     = DbDataType.Array;
            Array      sliceData  = null;
            Array      tempData   = null;
            Type       systemType = this.GetSystemType();

            int[] lengths     = new int[this.Descriptor.Dimensions];
            int[] lowerBounds = new int[this.Descriptor.Dimensions];
            int   type        = 0;
            int   index       = 0;

            // Get upper and lower bounds of each dimension
            for (int i = 0; i < this.Descriptor.Dimensions; i++)
            {
                lowerBounds[i] = this.Descriptor.Bounds[i].LowerBound;
                lengths[i]     = this.Descriptor.Bounds[i].UpperBound;

                if (lowerBounds[i] == 0)
                {
                    lengths[i]++;
                }
            }

            // Create arrays
#if     (NET_CF)
            sliceData = Array.CreateInstance(systemType, lengths);
#else
            sliceData = Array.CreateInstance(systemType, lengths, lowerBounds);
#endif
            tempData = Array.CreateInstance(systemType, sliceData.Length);

            // Infer Firebird and Db datatypes
            type   = TypeHelper.GetFbType(this.Descriptor.DataType);
            dbType = TypeHelper.GetDbDataType(this.Descriptor.DataType, 0, this.Descriptor.Scale);

            // Decode slice	data
            XdrStream xdr = new XdrStream(slice, this.database.Charset);

            while (xdr.Position < xdr.Length)
            {
                switch (dbType)
                {
                case DbDataType.Char:
                    tempData.SetValue(xdr.ReadString(this.Descriptor.Length), index);
                    break;

                case DbDataType.VarChar:
                    tempData.SetValue(xdr.ReadString(), index);
                    break;

                case DbDataType.SmallInt:
                    tempData.SetValue(xdr.ReadInt16(), index);
                    break;

                case DbDataType.Integer:
                    tempData.SetValue(xdr.ReadInt32(), index);
                    break;

                case DbDataType.BigInt:
                    tempData.SetValue(xdr.ReadInt64(), index);
                    break;

                case DbDataType.Numeric:
                case DbDataType.Decimal:
                    tempData.SetValue(xdr.ReadDecimal(type, this.Descriptor.Scale), index);
                    break;

                case DbDataType.Float:
                    tempData.SetValue(xdr.ReadSingle(), index);
                    break;

                case DbDataType.Double:
                    tempData.SetValue(xdr.ReadDouble(), index);
                    break;

                case DbDataType.Date:
                    tempData.SetValue(xdr.ReadDate(), index);
                    break;

                case DbDataType.Time:
                    tempData.SetValue(xdr.ReadTime(), index);
                    break;

                case DbDataType.TimeStamp:
                    tempData.SetValue(xdr.ReadDateTime(), index);
                    break;
                }

                index++;
            }

            if (systemType.IsPrimitive)
            {
                // For primitive types we can use System.Buffer	to copy	generated data to destination array
                Buffer.BlockCopy(tempData, 0, sliceData, 0, Buffer.ByteLength(tempData));
            }
            else
            {
                sliceData = tempData;
            }

            // Close XDR stream
            xdr.Close();

            return(sliceData);
        }
		protected override System.Array DecodeSlice(byte[] slice)
		{
			DbDataType	dbType		= DbDataType.Array;
			Array		sliceData	= null;
			Array		tempData	= null;
			Type		systemType	= GetSystemType();
			int[]		lengths		= new int[Descriptor.Dimensions];
			int[]		lowerBounds = new int[Descriptor.Dimensions];
			int			type		= 0;
			int			index		= 0;

			// Get upper and lower bounds of each dimension
			for (int i = 0; i < Descriptor.Dimensions; i++)
			{
				lowerBounds[i]	= Descriptor.Bounds[i].LowerBound;
				lengths[i]		= Descriptor.Bounds[i].UpperBound;

				if (lowerBounds[i] == 0)
				{
					lengths[i]++;
				}
			}

			// Create arrays
			sliceData = Array.CreateInstance(systemType, lengths, lowerBounds);
			tempData = Array.CreateInstance(systemType, sliceData.Length);

			// Infer Firebird and Db datatypes
			type	= TypeHelper.GetFbType(Descriptor.DataType);
			dbType	= TypeHelper.GetDbDataType(Descriptor.DataType, 0, Descriptor.Scale);

			// Decode slice	data
			XdrStream xdr = new XdrStream(slice, _database.Charset);

			while (xdr.Position < xdr.Length)
			{
				switch (dbType)
				{
					case DbDataType.Char:
						tempData.SetValue(xdr.ReadString(Descriptor.Length), index);
						break;

					case DbDataType.VarChar:
						tempData.SetValue(xdr.ReadString(), index);
						break;

					case DbDataType.SmallInt:
						tempData.SetValue(xdr.ReadInt16(), index);
						break;

					case DbDataType.Integer:
						tempData.SetValue(xdr.ReadInt32(), index);
						break;

					case DbDataType.BigInt:
						tempData.SetValue(xdr.ReadInt64(), index);
						break;

					case DbDataType.Numeric:
					case DbDataType.Decimal:
						tempData.SetValue(xdr.ReadDecimal(type, Descriptor.Scale), index);
						break;

					case DbDataType.Float:
						tempData.SetValue(xdr.ReadSingle(), index);
						break;

					case DbDataType.Double:
						tempData.SetValue(xdr.ReadDouble(), index);
						break;

					case DbDataType.Date:
						tempData.SetValue(xdr.ReadDate(), index);
						break;

					case DbDataType.Time:
						tempData.SetValue(xdr.ReadTime(), index);
						break;

					case DbDataType.TimeStamp:
						tempData.SetValue(xdr.ReadDateTime(), index);
						break;
				}

				index++;
			}

			if (systemType.IsPrimitive)
			{
				// For primitive types we can use System.Buffer	to copy	generated data to destination array
				Buffer.BlockCopy(tempData, 0, sliceData, 0, Buffer.ByteLength(tempData));
			}
			else
			{
				sliceData = tempData;
			}

			// Close XDR stream
			xdr.Close();

			return sliceData;
		}
 public decimal ReadDecimal(int type, int scale)
 {
     return(_inputStream.ReadDecimal(type, scale));
 }