示例#1
0
        /// <summary>
        /// Ctr.
        /// </summary>
        /// <param name="connection">Parent connection</param>
        /// <param name="inputStream">Incoming data stream from server</param>
        /// <param name="holders">Array of holder objects that must be disposed when reader is closed</param>
        public PqlDataReader(PqlDataConnection connection, BufferedReaderStream inputStream, params IDisposable[] holders)
        {
            m_protocolUtility = new PqlProtocolUtility(connection, inputStream, holders);
            try
            {
                m_reader = inputStream.MyReader;
                m_scheme = m_protocolUtility.ReadResponseHeaders(inputStream);

                if (m_scheme.Fields != null && m_scheme.Fields.Length > 0)
                {
                    m_currentRow = new RowData(m_scheme.Fields.Select(x => x.DataType).ToArray());
                    m_state      = ReaderState.New;
                }
                else
                {
                    m_state = ReaderState.Closed;
                }

                connection.SwitchToFetchingState();
            }
            catch
            {
                m_protocolUtility.Dispose();
                throw;
            }
        }
示例#2
0
        /// <summary>
        /// Ctr.
        /// </summary>
        /// <param name="connection">Parent connection</param>
        /// <param name="inputStream">Incoming data stream from server</param>
        /// <param name="holders">Array of holder objects that must be disposed when reader is closed</param>
        public PqlDataReader(PqlDataConnection connection, BufferedReaderStream inputStream, params IDisposable[] holders)
        {
            m_protocolUtility = new PqlProtocolUtility(connection, inputStream, holders);
            try
            {
                m_reader = inputStream.MyReader;
                m_scheme = m_protocolUtility.ReadResponseHeaders(inputStream);

                if (m_scheme.Fields != null && m_scheme.Fields.Length > 0)
                {
                    m_currentRow = new RowData(m_scheme.Fields.Select(x => x.DataType).ToArray());
                    m_state = ReaderState.New;
                }
                else
                {
                    m_state = ReaderState.Closed;
                }

                connection.SwitchToFetchingState();
            }
            catch
            {
                m_protocolUtility.Dispose();
                throw;
            }
        }
示例#3
0
        public ParsedRequest(bool forCache)
        {
            Select = SelectStatementData.Create();
            BaseDataset = BaseDatasetData.Create();
            Modify = InsertUpdateDeleteStatementData.Create();
            BulkInput = BulkInputData.Create();
            Params = ParametersData.Create();
            SpecialCommand = SpecialCommandData.Create();

            Bulk = forCache ? null : new BufferedReaderStream(84980);
        }
示例#4
0
        public void WriteTo(Stream stream)
        {
            if (m_dataRequest == null)
            {
                throw new InvalidOperationException("Cannot write when not attached to a command");
            }

            // write headers
            m_dataRequest.HaveRequestBulk = m_dataRequestBulk != null;
            m_dataRequest.HaveParameters  = m_dataRequestParams != null && m_dataRequestParams.DataTypes.Length > 0;
            Serializer.SerializeWithLengthPrefix(stream, m_dataRequest, PrefixStyle.Base128);

            // write parameters
            if (m_dataRequest.HaveParameters)
            {
                Serializer.SerializeWithLengthPrefix(stream, m_dataRequestParams, PrefixStyle.Base128);

                m_stream.SetLength(0);

                using (var bufferWriter = new BinaryWriter(m_stream, Encoding.UTF8, true))
                    using (var outputWriter = new BinaryWriter(stream, Encoding.UTF8, true))
                    {
                        // write notnull flags
                        var notnulls = new int[BitVector.GetArrayLength(m_dataRequestParams.Bulk.ParametersData.Count)];
                        for (var i = 0; i < m_dataRequestParams.Bulk.ParametersData.Count; i++)
                        {
                            var param = m_dataRequestParams.Bulk.ParametersData[i];
                            if (param.Value != null && param.Value != DBNull.Value)
                            {
                                BitVector.Set(notnulls, i);
                            }
                        }

                        BitVector.Write(notnulls, m_dataRequestParams.Bulk.ParametersData.Count, bufferWriter);

                        // write parameter data
                        for (var ordinal = 0; ordinal < m_dataRequestParams.Bulk.ParametersData.Count; ordinal++)
                        {
                            if (BitVector.Get(notnulls, ordinal))
                            {
                                var param = m_dataRequestParams.Bulk.ParametersData[ordinal];
                                param.Write(bufferWriter);
                            }

                            if (m_stream.Length > 1000000)
                            {
                                BufferedReaderStream.WriteBlock(outputWriter, m_stream);
                                m_stream.SetLength(0);
                            }
                        }

                        if (m_stream.Length > 0)
                        {
                            BufferedReaderStream.WriteBlock(outputWriter, m_stream);
                            m_stream.SetLength(0);
                        }

                        BufferedReaderStream.WriteStreamEndMarker(outputWriter);
                    }
            }

            // write data for bulk operation
            if (m_dataRequest.HaveRequestBulk)
            {
                Serializer.SerializeWithLengthPrefix(stream, m_dataRequestBulk, PrefixStyle.Base128);

                m_stream.SetLength(0);

                using (var bufferWriter = new BinaryWriter(m_stream, Encoding.UTF8, true))
                    using (var outputWriter = new BinaryWriter(stream, Encoding.UTF8, true))
                    {
                        foreach (var row in m_dataRequestBulk.Bulk)
                        {
                            row.Write(bufferWriter);

                            if (m_stream.Length > 1000000)
                            {
                                BufferedReaderStream.WriteBlock(outputWriter, m_stream);
                                m_stream.SetLength(0);
                            }
                        }

                        if (m_stream.Length > 0)
                        {
                            BufferedReaderStream.WriteBlock(outputWriter, m_stream);
                            m_stream.SetLength(0);
                        }

                        BufferedReaderStream.WriteStreamEndMarker(outputWriter);
                    }
            }
        }