Example #1
0
        /// <summary>
        /// +/- blocking
        /// </summary>
        /// <param name="nextAction"></param>
        public void Prepare(Action nextAction = null)
        {
            _execState     = QueryExecState.Prepare;
            _queryUsedMode = QueryUseMode.Prepare;

            if (_cmdParams == null)
            {
                throw new Exception("Sql cmdParams can not null.");
            }
            //-------------------
            //blocking method***
            //wait until execute finish
            //-------------------
            //prepare sql query
            _sqlParserMx.UsePrepareResponseParser();
            _prepareContext = null;
            //-------------------------------------------------------------
            _writer.Reset();
            ComPrepareStatementPacket.Write(
                _writer,
                _sqlStrTemplate.BindValues(_cmdParams, true));
            //-------------------------------------------------------------
            if (nextAction != null)
            {
                //not block here
                SendAndRecv_A(_writer.ToArray(), nextAction);
            }
            else
            {
                //blocking
                _conn.InitWait();
                SendAndRecv_A(_writer.ToArray(), _conn.UnWait);
                _conn.Wait();
            }
        }
Example #2
0
        public void Prepare()
        {
            //prepare sql query
            _prepareContext = null;

            if (_cmdParams == null)
            {
                return;
            }

            _writer.Reset();

            string realSql = _sqlStrTemplate.BindValues(_cmdParams, true);
            ComPrepareStatementPacket preparePacket = new ComPrepareStatementPacket(realSql);

            preparePacket.WritePacket(_writer);
            SendPacket(_writer.ToArray());

            OkPrepareStmtPacket okPreparePacket = new OkPrepareStmtPacket();

            okPreparePacket = ParsePrepareResponse();
            if (okPreparePacket != null)
            {
                _prepareContext = new PreparedContext(okPreparePacket.statement_id, _sqlStrTemplate);

                if (okPreparePacket.num_params > 0)
                {
                    var tableHeader = new TableHeader();
                    tableHeader.TypeCast   = typeCast;
                    tableHeader.NestTables = nestTables;
                    tableHeader.ConnConfig = _conn.config;
                    for (int i = 0; i < okPreparePacket.num_params; i++)
                    {
                        //no meaing for each field?
                        FieldPacket field = ParseColumn();
                        tableHeader.AddField(field);
                    }

                    //set table after the table is ready!
                    _prepareContext.Setup(tableHeader);

                    ParseEOF();
                }
                if (okPreparePacket.num_columns > 0)
                {
                    _tableHeader            = new TableHeader();
                    _tableHeader.TypeCast   = typeCast;
                    _tableHeader.NestTables = nestTables;
                    _tableHeader.ConnConfig = _conn.config;

                    for (int i = 0; i < okPreparePacket.num_columns; i++)
                    {
                        FieldPacket field = ParseColumn();
                        _tableHeader.AddField(field);
                    }
                    ParseEOF();
                }
            }
        }
Example #3
0
        void ExecuteNonPrepare()
        {
            _writer.Reset();

            string realSql = _sqlStrTemplate.BindValues(_cmdParams, false);

            var queryPacket = new ComQueryPacket(realSql);

            queryPacket.WritePacket(_writer);
            SendPacket(_writer.ToArray());

            _prepareContext = null;
            ParseReceivePacket();
        }
Example #4
0
        void RecvPacket_A(Action whenRecv)
        {
            _recvComplete = false;
            bool isFirstRecv = true;

            //before start recv
            _conn.StartReceive(result =>
            {
                if (result == null)
                {
                    throw new NotSupportedException();
                }
                else
                {
                    switch (result.Kind)
                    {
                    default: throw new NotSupportedException();    //unknown

                    case MySqlResultKind.Ok:
                        {
                            OkPacket = (result as MySqlOkResult).okpacket;
                            RecvComplete();
                        }
                        break;

                    case MySqlResultKind.Error:
                        {
                            MySqlErrorResult error = result as MySqlErrorResult;
                            Error = error.errPacket;
                            RecvComplete();
                            if (_errorListener != null)
                            {
                                _errorListener(error);
                            }
                            else
                            {
                                //ERROR
                                throw new MySqlExecException(error);
                            }
                        }
                        break;

                    case MySqlResultKind.PrepareResponse:
                        {
                            //The server will send a OK_Packet if the statement could be reset, a ERR_Packet if not.
                            //on prepare
                            MySqlPrepareResponseResult response = result as MySqlPrepareResponseResult;
                            _prepareContext = new PreparedContext(
                                response.okPacket.statement_id,
                                _sqlStrTemplate,
                                response.tableHeader);
                            RecvComplete();
                        }
                        break;

                    case MySqlResultKind.TableResult:
                        {
                            //support partial table mode
                            //last sub table is not partial table
                            //and must notify reader first***
                            //before call  RecvComplete();

                            //-----------------------------------------
                            MySqlTableResult tableResult = result as MySqlTableResult;
                            //***
                            _recvComplete = !tableResult.HasFollower;
                            //the _tableResultListener may modifid by other state (Close)
                            //if don't lock we need to store it to local var
                            _tableResultListener?.Invoke(tableResult);
                            //-----------------------------------------
                            if (!tableResult.HasFollower)
                            {
                                RecvComplete();
                            }
                        }
                        break;

                    case MySqlResultKind.MultiTableResult:
                        {
                            MySqlMultiTableResult multiTables = result as MySqlMultiTableResult;
                            List <MySqlTableResult> subTables = multiTables.subTables;
                            int j = subTables.Count;
                            for (int i = 0; i < j; ++i)
                            {
                                MySqlTableResult table = subTables[i];
                                if (i < j - 1)
                                {
                                    //not the last one
                                    //(the last one may complete or not complete)
                                    table.HasFollower = true;

                                    //the _tableResultListener may modifid by other state (Close)
                                    //if don't lock we need to store it to local var
                                    _tableResultListener?.Invoke(table);
                                }
                                else
                                {
                                    //this is the last one in the series
                                    //support partial table mode
                                    //last sub table is not partial table
                                    //and must notify reader first***
                                    //before call  RecvComplete();

                                    _recvComplete = !table.HasFollower;

                                    //the _tableResultListener may modifid by other state (Close)
                                    //if don't lock we need to store it to local var
                                    _tableResultListener?.Invoke(table);

                                    if (!table.HasFollower)
                                    {
                                        RecvComplete();
                                    }
                                }
                            }
                        }
                        break;
                    }
                }
                //-----------------
                //exec once
                if (isFirstRecv)
                {
                    isFirstRecv = false;
                    whenRecv();
                    whenRecv = null;
                }
                //-----------------
            });
        }
Example #5
0
        void RecvPacket_A(Action whenRecv)
        {

            _recvComplete = false;
            bool isFirstRecv = true;
            _conn.StartReceive(result =>
            {
                if (result == null)
                {
                    throw new NotSupportedException();
                }
                else
                {
                    switch (result.Kind)
                    {
                        default: throw new NotSupportedException();//unknown
                        case MySqlResultKind.Ok:
                            {
                                MySqlOkResult ok = result as MySqlOkResult;
                                OkPacket = ok.okpacket;

                                RecvComplete();
                            }
                            break;
                        case MySqlResultKind.Error:
                            {
                                MySqlErrorResult error = result as MySqlErrorResult;
                                LoadError = error.errPacket;
                                RecvComplete();
                            }
                            break;
                        case MySqlResultKind.PrepareResponse:
                            {
                                //The server will send a OK_Packet if the statement could be reset, a ERR_Packet if not.
                                //on prepare
                                MySqlPrepareResponseResult response = result as MySqlPrepareResponseResult;
                                _prepareContext = new PreparedContext(
                                    response.okPacket.statement_id,
                                    _sqlStrTemplate,
                                    response.tableHeader);
                                RecvComplete();
                            }
                            break;
                        case MySqlResultKind.TableResult:
                            {
                                //support partial table mode 
                                //last sub table is not partial table  
                                //and must notify reader first***
                                //before call  RecvComplete();

                                //-----------------------------------------  
                                MySqlTableResult tableResult = result as MySqlTableResult;
                                //***
                                _recvComplete = !tableResult.HasFollower;

                                if (_tableResultListener != null)
                                {
                                    //the _tableResultListener may modifid by other state (Close)
                                    //if don't lock we need to store it to local var
                                    _tableResultListener(tableResult);
                                }

                                //----------------------------------------- 
                                if (!tableResult.HasFollower)
                                {
                                    RecvComplete();
                                }
                            }
                            break;
                        case MySqlResultKind.MultiTableResult:
                            {
                                MySqlMultiTableResult multiTables = result as MySqlMultiTableResult;
                                List<MySqlTableResult> subTables = multiTables.subTables;
                                int j = subTables.Count;
                                for (int i = 0; i < j; ++i)
                                {
                                    MySqlTableResult table = subTables[i];
                                    if (i < j - 1)
                                    {
                                        //not the last one
                                        //(the last one may complete or not complete)
                                        table.HasFollower = true;
                                        if (_tableResultListener != null)
                                        {
                                            //the _tableResultListener may modifid by other state (Close)
                                            //if don't lock we need to store it to local var
                                            _tableResultListener(table);
                                        }
                                    }
                                    else
                                    {
                                        //this is the last one in the series
                                        //support partial table mode 
                                        //last sub table is not partial table  
                                        //and must notify reader first***
                                        //before call  RecvComplete();

                                        _recvComplete = !table.HasFollower;
                                        if (_tableResultListener != null)
                                        {
                                            //the _tableResultListener may modifid by other state (Close)
                                            //if don't lock we need to store it to local var
                                            _tableResultListener(table);
                                        }

                                        if (!table.HasFollower)
                                        {
                                            RecvComplete();
                                        }
                                    }
                                }

                            }
                            break;
                    }
                }
                //-----------------
                //exec once
                if (isFirstRecv)
                {
                    isFirstRecv = false;
                    whenRecv();
                    whenRecv = null;
                }
                //-----------------
            });
        }
Example #6
0
        /// <summary>
        /// +/- blocking
        /// </summary>
        /// <param name="nextAction"></param>
        public void Prepare(Action nextAction = null)
        {
            _execState = QueryExecState.Prepare;
            _queryUsedMode = QueryUseMode.Prepare;

            if (_cmdParams == null)
            {
                throw new Exception("Sql cmdParams can not null.");
            }
            //-------------------
            //blocking method***
            //wait until execute finish 
            //-------------------
            //prepare sql query             
            _sqlParserMx.UsePrepareResponseParser();
            _prepareContext = null;
            //-------------------------------------------------------------
            _writer.Reset();
            ComPrepareStatementPacket.Write(
                _writer,
                _sqlStrTemplate.BindValues(_cmdParams, true));
            //-------------------------------------------------------------
            if (nextAction != null)
            {
                //not block here
                SendAndRecv_A(_writer.ToArray(), nextAction);
            }
            else
            {
                //blocking
                _conn.InitWait();
                SendAndRecv_A(_writer.ToArray(), _conn.UnWait);
                _conn.Wait();
            }
        }