public override string ToString()
        {
            if (InputParameters == null && InputValues == null)
            {
                return(string.Empty);
            }

            if (InputParameters == null)
            {
                return(ObjectToStringConverter.ConvertCollectionToString(InputValues));
            }

            if (InputValues == null)
            {
                return(ObjectToStringConverter.ConvertCollectionToString(InputParameters.Select(p => p.Name)));
            }

            return(ObjectToStringConverter.ConvertSomeToString(InputParameters.Select(p => p.Name).ToArray(), InputValues));
        }
Example #2
0
        internal override bool Write(NpgsqlBuffer buf, ref byte[] directBuf)
        {
            Contract.Requires(Statement != null && Statement.All(c => c < 128));
            Contract.Requires(Portal != null && Portal.All(c => c < 128));

            switch (_state)
            {
            case State.WroteNothing:
                var formatCodesSum       = InputParameters.Select(p => p.FormatCode).Sum(c => (int)c);
                var formatCodeListLength = formatCodesSum == 0 ? 0 : formatCodesSum == InputParameters.Count ? 1 : InputParameters.Count;

                var headerLength =
                    4 +                            // Message length
                    Portal.Length + 1 +
                    Statement.Length + 1 +
                    2 +                            // Number of parameter format codes that follow
                    2 * formatCodeListLength +     // List of format codes
                    2;                             // Number of parameters

                if (buf.WriteSpaceLeft < headerLength)
                {
                    if (buf.Size < headerLength)
                    {
                        throw new Exception("Buffer too small for Bind header");
                    }
                    return(false);
                }

                var messageLength = headerLength +
                                    4 * InputParameters.Count +                                             // Parameter lengths
                                    InputParameters.Select(p => p.BoundSize).Sum() +                        // Parameter values
                                    2 +                                                                     // Number of result format codes
                                    2 * (UnknownResultTypeList == null ? 1 : UnknownResultTypeList.Length); // Result format codes

                buf.WriteByte(Code);
                buf.WriteInt32(messageLength);
                buf.WriteBytesNullTerminated(Encoding.ASCII.GetBytes(Portal));
                buf.WriteBytesNullTerminated(Encoding.ASCII.GetBytes(Statement));

                // 0 implicitly means all-text, 1 means all binary, >1 means mix-and-match
                buf.WriteInt16(formatCodeListLength);
                if (formatCodeListLength == 1)
                {
                    buf.WriteInt16((short)FormatCode.Binary);
                }
                else if (formatCodeListLength > 1)
                {
                    foreach (var code in InputParameters.Select(p => p.FormatCode))
                    {
                        buf.WriteInt16((short)code);
                    }
                }

                buf.WriteInt16(InputParameters.Count);
                _state = State.WroteHeader;
                goto case State.WroteHeader;

            case State.WroteHeader:
                if (!WriteParameters(buf, ref directBuf))
                {
                    return(false);
                }
                _state = State.WroteParameters;
                goto case State.WroteParameters;

            case State.WroteParameters:
                if (UnknownResultTypeList != null)
                {
                    if (buf.WriteSpaceLeft < 2 + UnknownResultTypeList.Length * 2)
                    {
                        return(false);
                    }
                    buf.WriteInt16(UnknownResultTypeList.Length);
                    foreach (var t in UnknownResultTypeList)
                    {
                        buf.WriteInt16(t ? 0 : 1);
                    }
                }
                else
                {
                    if (buf.WriteSpaceLeft < 4)
                    {
                        return(false);
                    }
                    buf.WriteInt16(1);
                    buf.WriteInt16(AllResultTypesAreUnknown ? 0 : 1);
                }

                _state = State.Done;
                return(true);

            default:
                throw PGUtil.ThrowIfReached();
            }
        }
Example #3
0
        internal bool Write(WriteBuffer buf, ref DirectBuffer directBuf)
        {
            Contract.Requires(Statement != null && Statement.All(c => c < 128));
            Contract.Requires(Portal != null && Portal.All(c => c < 128));

            switch (_state)
            {
            case State.Header:
                var formatCodesSum = InputParameters.Select(p => p.FormatCode).Sum(c => (int)c);
                _formatCodeListLength = formatCodesSum == 0 ? 0 : formatCodesSum == InputParameters.Count ? 1 : InputParameters.Count;
                var headerLength =
                    1 +                            // Message code
                    4 +                            // Message length
                    Portal.Length + 1 +
                    Statement.Length + 1 +
                    2;                             // Number of parameter format codes that follow

                if (buf.WriteSpaceLeft < headerLength)
                {
                    Contract.Assume(buf.Size >= headerLength, "Buffer too small for Bind header");
                    return(false);
                }

                foreach (var c in InputParameters.Select(p => p.LengthCache).Where(c => c != null))
                {
                    c.Rewind();
                }
                var messageLength = headerLength +
                                    2 * _formatCodeListLength +                                   // List of format codes
                                    2 +                                                           // Number of parameters
                                    4 * InputParameters.Count +                                   // Parameter lengths
                                    InputParameters.Select(p => p.ValidateAndGetLength()).Sum() + // Parameter values
                                    2 +                                                           // Number of result format codes
                                    2 * (UnknownResultTypeList?.Length ?? 1);                     // Result format codes

                buf.WriteByte(Code);
                buf.WriteInt32(messageLength - 1);
                buf.WriteBytesNullTerminated(Encoding.ASCII.GetBytes(Portal));
                buf.WriteBytesNullTerminated(Encoding.ASCII.GetBytes(Statement));
                buf.WriteInt16(_formatCodeListLength);
                _paramIndex = 0;

                _state = State.ParameterFormatCodes;
                goto case State.ParameterFormatCodes;

            case State.ParameterFormatCodes:
                // 0 length implicitly means all-text, 1 means all-binary, >1 means mix-and-match
                if (_formatCodeListLength == 1)
                {
                    if (buf.WriteSpaceLeft < 2)
                    {
                        return(false);
                    }
                    buf.WriteInt16((short)FormatCode.Binary);
                }
                else if (_formatCodeListLength > 1)
                {
                    for (; _paramIndex < InputParameters.Count; _paramIndex++)
                    {
                        if (buf.WriteSpaceLeft < 2)
                        {
                            return(false);
                        }
                        buf.WriteInt16((short)InputParameters[_paramIndex].FormatCode);
                    }
                }

                if (buf.WriteSpaceLeft < 2)
                {
                    return(false);
                }

                buf.WriteInt16(InputParameters.Count);
                _paramIndex = 0;

                _state = State.ParameterValues;
                goto case State.ParameterValues;

            case State.ParameterValues:
                if (!WriteParameters(buf, ref directBuf))
                {
                    return(false);
                }
                _state = State.ResultFormatCodes;
                goto case State.ResultFormatCodes;

            case State.ResultFormatCodes:
                if (UnknownResultTypeList != null)
                {
                    if (buf.WriteSpaceLeft < 2 + UnknownResultTypeList.Length * 2)
                    {
                        return(false);
                    }
                    buf.WriteInt16(UnknownResultTypeList.Length);
                    foreach (var t in UnknownResultTypeList)
                    {
                        buf.WriteInt16(t ? 0 : 1);
                    }
                }
                else
                {
                    if (buf.WriteSpaceLeft < 4)
                    {
                        return(false);
                    }
                    buf.WriteInt16(1);
                    buf.WriteInt16(AllResultTypesAreUnknown ? 0 : 1);
                }

                _state = State.Done;
                return(true);

            default:
                throw PGUtil.ThrowIfReached();
            }
        }