Exemplo n.º 1
0
 protected virtual void ReadRow(DbValueBase[] row)
 {
     try
     {
         for (int i = 0; i < _fields.Count; i++)
         {
             var value  = ReadRawValue(_fields[i]);
             var sqlInd = _database.XdrStream.ReadInt32();
             if (sqlInd == -1)
             {
                 row[i] = NullDbValue.Instance;
             }
             else if (sqlInd == 0)
             {
                 row[i] = value;
             }
             else
             {
                 throw IscException.ForStrParam($"Invalid {nameof(sqlInd)} value: {sqlInd}.");
             }
         }
     }
     catch (IOException ex)
     {
         throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
     }
 }
Exemplo n.º 2
0
        protected virtual DbValue[] ReadRow()
        {
            var row = new DbValue[_fields.Count];

            try
            {
                for (var i = 0; i < _fields.Count; i++)
                {
                    var value  = ReadRawValue(_fields[i]);
                    var sqlInd = _database.Xdr.ReadInt32();
                    if (sqlInd == -1)
                    {
                        row[i] = new DbValue(this, _fields[i], null);
                    }
                    else if (sqlInd == 0)
                    {
                        row[i] = new DbValue(this, _fields[i], value);
                    }
                    else
                    {
                        throw IscException.ForStrParam($"Invalid {nameof(sqlInd)} value: {sqlInd}.");
                    }
                }
            }
            catch (IOException ex)
            {
                throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
            }
            return(row);
        }
 private void EnsureArray()
 {
     if (!IsArray())
     {
         throw IscException.ForStrParam("Field is not an array type.");
     }
 }
        protected virtual async Task <DbValue[]> ReadRow(AsyncWrappingCommonArgs async)
        {
            var row = new DbValue[_fields.Count];

            try
            {
                for (var i = 0; i < _fields.Count; i++)
                {
                    var value = await ReadRawValue(_database.Xdr, _fields[i], async).ConfigureAwait(false);

                    var sqlInd = await _database.Xdr.ReadInt32(async).ConfigureAwait(false);

                    if (sqlInd == -1)
                    {
                        row[i] = new DbValue(this, _fields[i], null);
                    }
                    else if (sqlInd == 0)
                    {
                        row[i] = new DbValue(this, _fields[i], value);
                    }
                    else
                    {
                        throw IscException.ForStrParam($"Invalid {nameof(sqlInd)} value: {sqlInd}.");
                    }
                }
            }
            catch (IOException ex)
            {
                throw IscException.ForIOException(ex);
            }
            return(row);
        }
Exemplo n.º 5
0
        protected void WriteRawParameter(XdrBinaryWriter xdr, DbField field)
        {
            if (field.DbDataType != DbDataType.Null)
            {
                field.FixNull();

                switch (field.DbDataType)
                {
                case DbDataType.Char:
                    if (field.Charset.IsOctetsCharset)
                    {
                        xdr.WriteOpaque(field.DbValue.GetBinary(), field.Length);
                    }
                    else
                    {
                        var svalue = field.DbValue.GetString();

                        if ((field.Length % field.Charset.BytesPerCharacter) == 0 &&
                            svalue.Length > field.CharCount)
                        {
                            throw IscException.ForErrorCodes(new[] { IscCodes.isc_arith_except, IscCodes.isc_string_truncation });
                        }

                        xdr.WriteOpaque(field.Charset.GetBytes(svalue), field.Length);
                    }
                    break;

                case DbDataType.VarChar:
                    if (field.Charset.IsOctetsCharset)
                    {
                        xdr.WriteBuffer(field.DbValue.GetBinary());
                    }
                    else
                    {
                        var svalue = field.DbValue.GetString();

                        if ((field.Length % field.Charset.BytesPerCharacter) == 0 &&
                            svalue.Length > field.CharCount)
                        {
                            throw IscException.ForErrorCodes(new[] { IscCodes.isc_arith_except, IscCodes.isc_string_truncation });
                        }

                        xdr.WriteBuffer(field.Charset.GetBytes(svalue));
                    }
                    break;

                case DbDataType.SmallInt:
                    xdr.Write(field.DbValue.GetInt16());
                    break;

                case DbDataType.Integer:
                    xdr.Write(field.DbValue.GetInt32());
                    break;

                case DbDataType.BigInt:
                case DbDataType.Array:
                case DbDataType.Binary:
                case DbDataType.Text:
                    xdr.Write(field.DbValue.GetInt64());
                    break;

                case DbDataType.Decimal:
                case DbDataType.Numeric:
                    xdr.Write(field.DbValue.GetDecimal(), field.DataType, field.NumericScale);
                    break;

                case DbDataType.Float:
                    xdr.Write(field.DbValue.GetFloat());
                    break;

                case DbDataType.Guid:
                    xdr.WriteOpaque(field.DbValue.GetGuid().ToByteArray());
                    break;

                case DbDataType.Double:
                    xdr.Write(field.DbValue.GetDouble());
                    break;

                case DbDataType.Date:
                    xdr.Write(field.DbValue.GetDate());
                    break;

                case DbDataType.Time:
                    xdr.Write(field.DbValue.GetTime());
                    break;

                case DbDataType.TimeStamp:
                    xdr.Write(field.DbValue.GetDate());
                    xdr.Write(field.DbValue.GetTime());
                    break;

                case DbDataType.Boolean:
                    xdr.Write(Convert.ToBoolean(field.Value));
                    break;

                default:
                    throw IscException.ForStrParam($"Unknown SQL data type: {field.DataType}.");
                }
            }
        }
    public void FixNull()
    {
        if (NullFlag == -1 && _dbValue.IsDBNull())
        {
            switch (DbDataType)
            {
            case DbDataType.Char:
            case DbDataType.VarChar:
                DbValue.SetValue(string.Empty);
                break;

            case DbDataType.Guid:
                DbValue.SetValue(Guid.Empty);
                break;

            case DbDataType.SmallInt:
                DbValue.SetValue((short)0);
                break;

            case DbDataType.Integer:
                DbValue.SetValue((int)0);
                break;

            case DbDataType.BigInt:
            case DbDataType.Binary:
            case DbDataType.Array:
            case DbDataType.Text:
                DbValue.SetValue((long)0);
                break;

            case DbDataType.Numeric:
            case DbDataType.Decimal:
                DbValue.SetValue((decimal)0);
                break;

            case DbDataType.Float:
                DbValue.SetValue((float)0);
                break;

            case DbDataType.Double:
                DbValue.SetValue((double)0);
                break;

            case DbDataType.Date:
            case DbDataType.TimeStamp:
                DbValue.SetValue(DateTime2.UnixEpoch);
                break;

            case DbDataType.Time:
                DbValue.SetValue(TimeSpan.Zero);
                break;

            case DbDataType.Boolean:
                DbValue.SetValue(false);
                break;

            case DbDataType.TimeStampTZ:
            case DbDataType.TimeStampTZEx:
                DbValue.SetValue(new FbZonedDateTime(DateTime2.UnixEpoch, TimeZoneMapping.DefaultTimeZoneName));
                break;

            case DbDataType.TimeTZ:
            case DbDataType.TimeTZEx:
                DbValue.SetValue(new FbZonedTime(TimeSpan.Zero, TimeZoneMapping.DefaultTimeZoneName));
                break;

            case DbDataType.Dec16:
            case DbDataType.Dec34:
                DbValue.SetValue(new FbDecFloat(0, 0));
                break;

            case DbDataType.Int128:
                DbValue.SetValue((BigInteger)0);
                break;

            default:
                throw IscException.ForStrParam($"Unknown sql data type: {DataType}.");
            }
        }
    }
        protected async Task WriteRawParameter(IXdrWriter xdr, DbField field, AsyncWrappingCommonArgs async)
        {
            if (field.DbDataType != DbDataType.Null)
            {
                await field.FixNull(async).ConfigureAwait(false);

                switch (field.DbDataType)
                {
                case DbDataType.Char:
                    if (field.Charset.IsOctetsCharset)
                    {
                        await xdr.WriteOpaque(await field.DbValue.GetBinary(async).ConfigureAwait(false), field.Length, async).ConfigureAwait(false);
                    }
                    else if (field.Charset.IsNoneCharset)
                    {
                        var bvalue = field.Charset.GetBytes(await field.DbValue.GetString(async).ConfigureAwait(false));
                        if (bvalue.Length > field.Length)
                        {
                            throw IscException.ForErrorCodes(new[] { IscCodes.isc_arith_except, IscCodes.isc_string_truncation });
                        }
                        await xdr.WriteOpaque(bvalue, field.Length, async).ConfigureAwait(false);
                    }
                    else
                    {
                        var svalue = await field.DbValue.GetString(async).ConfigureAwait(false);

                        if ((field.Length % field.Charset.BytesPerCharacter) == 0 && svalue.Length > field.CharCount)
                        {
                            throw IscException.ForErrorCodes(new[] { IscCodes.isc_arith_except, IscCodes.isc_string_truncation });
                        }
                        await xdr.WriteOpaque(field.Charset.GetBytes(svalue), field.Length, async).ConfigureAwait(false);
                    }
                    break;

                case DbDataType.VarChar:
                    if (field.Charset.IsOctetsCharset)
                    {
                        await xdr.WriteBuffer(await field.DbValue.GetBinary(async).ConfigureAwait(false), async).ConfigureAwait(false);
                    }
                    else if (field.Charset.IsNoneCharset)
                    {
                        var bvalue = field.Charset.GetBytes(await field.DbValue.GetString(async).ConfigureAwait(false));
                        if (bvalue.Length > field.Length)
                        {
                            throw IscException.ForErrorCodes(new[] { IscCodes.isc_arith_except, IscCodes.isc_string_truncation });
                        }
                        await xdr.WriteBuffer(bvalue, async).ConfigureAwait(false);
                    }
                    else
                    {
                        var svalue = await field.DbValue.GetString(async).ConfigureAwait(false);

                        if ((field.Length % field.Charset.BytesPerCharacter) == 0 && svalue.Length > field.CharCount)
                        {
                            throw IscException.ForErrorCodes(new[] { IscCodes.isc_arith_except, IscCodes.isc_string_truncation });
                        }
                        await xdr.WriteBuffer(field.Charset.GetBytes(svalue), async).ConfigureAwait(false);
                    }
                    break;

                case DbDataType.SmallInt:
                    await xdr.Write(await field.DbValue.GetInt16(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.Integer:
                    await xdr.Write(await field.DbValue.GetInt32(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.BigInt:
                case DbDataType.Array:
                case DbDataType.Binary:
                case DbDataType.Text:
                    await xdr.Write(await field.DbValue.GetInt64(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.Decimal:
                case DbDataType.Numeric:
                    await xdr.Write(await field.DbValue.GetDecimal(async).ConfigureAwait(false), field.DataType, field.NumericScale, async).ConfigureAwait(false);

                    break;

                case DbDataType.Float:
                    await xdr.Write(await field.DbValue.GetFloat(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.Guid:
                    await xdr.Write(await field.DbValue.GetGuid(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.Double:
                    await xdr.Write(await field.DbValue.GetDouble(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.Date:
                    await xdr.Write(await field.DbValue.GetDate(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.Time:
                    await xdr.Write(await field.DbValue.GetTime(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.TimeStamp:
                    await xdr.Write(await field.DbValue.GetDate(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    await xdr.Write(await field.DbValue.GetTime(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.Boolean:
                    await xdr.Write(await field.DbValue.GetBoolean(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.TimeStampTZ:
                    await xdr.Write(await field.DbValue.GetDate(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    await xdr.Write(await field.DbValue.GetTime(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    await xdr.Write(await field.DbValue.GetTimeZoneId(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.TimeStampTZEx:
                    await xdr.Write(await field.DbValue.GetDate(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    await xdr.Write(await field.DbValue.GetTime(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    await xdr.Write(await field.DbValue.GetTimeZoneId(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    await xdr.Write((short)0, async).ConfigureAwait(false);

                    break;

                case DbDataType.TimeTZ:
                    await xdr.Write(await field.DbValue.GetTime(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    await xdr.Write(await field.DbValue.GetTimeZoneId(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                case DbDataType.TimeTZEx:
                    await xdr.Write(await field.DbValue.GetTime(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    await xdr.Write(await field.DbValue.GetTimeZoneId(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    await xdr.Write((short)0, async).ConfigureAwait(false);

                    break;

                case DbDataType.Dec16:
                    await xdr.Write(await field.DbValue.GetDec16(async).ConfigureAwait(false), 16, async).ConfigureAwait(false);

                    break;

                case DbDataType.Dec34:
                    await xdr.Write(await field.DbValue.GetDec34(async).ConfigureAwait(false), 34, async).ConfigureAwait(false);

                    break;

                case DbDataType.Int128:
                    await xdr.Write(await field.DbValue.GetInt128(async).ConfigureAwait(false), async).ConfigureAwait(false);

                    break;

                default:
                    throw IscException.ForStrParam($"Unknown SQL data type: {field.DataType}.");
                }
            }
        }