예제 #1
0
파일: QueryAdapter.cs 프로젝트: BjkGkh/R106
 public bool findsResult()
 {
     watch.Restart();
     bool hasRows = false;
     try
     {
         using (reader = this.command.ExecuteReader())
         {
             hasRows = reader.HasRows;
         }
     }
     catch (Exception exception)
     {
         Writer.LogQueryError(exception, this.command.CommandText);
     }
     DatabaseStats.totalQueryTime += watch.ElapsedMilliseconds;
     DatabaseStats.totalQueries++;
     return hasRows;
 }
예제 #2
0
        public override void Close(MySqlDataReader reader)
        {
            base.Close(reader);
              if (String.IsNullOrEmpty(outSelect)) return;
              if ((reader.CommandBehavior & CommandBehavior.SchemaOnly) != 0) return;

              MySqlCommand cmd = new MySqlCommand(outSelect, command.Connection);
              using (MySqlDataReader rdr = cmd.ExecuteReader(reader.CommandBehavior))
              {
            ProcessOutputParameters(rdr);
              }
        }
예제 #3
0
        private void AdjustOutputTypes(MySqlDataReader reader)
        {
            // since MySQL likes to return user variables as strings
              // we reset the types of the readers internal value objects
              // this will allow those value objects to parse the string based
              // return values
              for (int i = 0; i < reader.FieldCount; i++)
              {
            string fieldName = reader.GetName(i);
            if (fieldName.IndexOf(StoredProcedure.ParameterPrefix) != -1)
              fieldName = fieldName.Remove(0, StoredProcedure.ParameterPrefix.Length + 1);
            MySqlParameter parameter = command.Parameters.GetParameterFlexible(fieldName, true);

            IMySqlValue v = MySqlField.GetIMySqlValue(parameter.MySqlDbType);
            if (v is MySqlBit)
            {
              MySqlBit bit = (MySqlBit)v;
              bit.ReadAsString = true;
              reader.ResultSet.SetValueObject(i, bit);
            }
            else
              reader.ResultSet.SetValueObject(i, v);
              }
        }
예제 #4
0
        internal void ProcessOutputParameters(MySqlDataReader reader)
        {
            // We apparently need to always adjust our output types since the server
              // provided data types are not always right
              AdjustOutputTypes(reader);

              if ((reader.CommandBehavior & CommandBehavior.SchemaOnly) != 0)
            return;

              // now read the output parameters data row
              reader.Read();

              string prefix = "@" + StoredProcedure.ParameterPrefix;

              for (int i = 0; i < reader.FieldCount; i++)
              {
            string fieldName = reader.GetName(i);
            if (fieldName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
              fieldName = fieldName.Remove(0, prefix.Length);
            MySqlParameter parameter = command.Parameters.GetParameterFlexible(fieldName, true);
            parameter.Value = reader.GetValue(i);
              }
        }
예제 #5
0
 private static string GetString(MySqlDataReader reader, int index)
 {
     if (reader.IsDBNull(index))
     return null;
       return reader.GetString(index);
 }
예제 #6
0
파일: Statement.cs 프로젝트: BjkGkh/R106
 public virtual void Close(MySqlDataReader reader)
 {
 }
예제 #7
0
파일: command.cs 프로젝트: BjkGkh/R106
 internal void Close(MySqlDataReader reader)
 {
     if (statement != null)
     statement.Close(reader);
       ResetSqlSelectLimit();
       if (statement != null && connection != null && connection.driver != null)
     connection.driver.CloseQuery(connection, statement.StatementId);
       ClearCommandTimer();
 }
예제 #8
0
파일: command.cs 프로젝트: BjkGkh/R106
        public new MySqlDataReader ExecuteReader(CommandBehavior behavior)
        {
            // interceptors didn't handle this so we fall through
              bool success = false;
              CheckState();
              Driver driver = connection.driver;
              lock (driver)
              {

            // We have to recheck that there is no reader, after we got the lock
            if (connection.Reader != null)
            {
              Throw(new MySqlException(Resources.DataReaderOpen));
            }
            commandTimer = new CommandTimer(connection, CommandTimeout);

            lastInsertedId = -1;
            cmdText = cmdText.Trim();
            if (String.IsNullOrEmpty(cmdText))
              Throw(new InvalidOperationException(Resources.CommandTextNotInitialized));

            string sql = cmdText.Trim(';');

            if (CommandType == CommandType.TableDirect)
              sql = "SELECT * FROM " + sql;
            else if (CommandType == CommandType.Text)
            {
              // validates single word statetment (maybe is a stored procedure call)
              if (sql.IndexOf(" ") == -1 && !SingleWordKeywords.Contains(sql.ToUpper()))
              {
            sql = "call " + sql;
              }
            }

            // if we are on a replicated connection, we are only allow readonly statements
            if (connection.Settings.Replication && !InternallyCreated)
              EnsureCommandIsReadOnly(sql);

            if (statement == null || !statement.IsPrepared)
            {
              if (CommandType == CommandType.StoredProcedure)
            statement = new StoredProcedure(this, sql);
              else
            statement = new PreparableStatement(this, sql);
            }

            // stored procs are the only statement type that need do anything during resolve
            statement.Resolve(false);

            // Now that we have completed our resolve step, we can handle our
            // command behaviors
            HandleCommandBehaviors(behavior);

            try
            {
              MySqlDataReader reader = new MySqlDataReader(this, statement, behavior);
              connection.Reader = reader;
              canceled = false;
              // execute the statement
              statement.Execute();
              // wait for data to return
              reader.NextResult();
              success = true;
              return reader;
            }
            catch (TimeoutException tex)
            {
              connection.HandleTimeoutOrThreadAbort(tex);
              throw; //unreached
            }
            catch (ThreadAbortException taex)
            {
              connection.HandleTimeoutOrThreadAbort(taex);
              throw;
            }
            catch (IOException ioex)
            {
              connection.Abort(); // Closes connection without returning it to the pool
              throw new MySqlException(Resources.FatalErrorDuringExecute, ioex);
            }
            catch (MySqlException ex)
            {

              if (ex.InnerException is TimeoutException)
            throw; // already handled

              try
              {
            ResetReader();
            ResetSqlSelectLimit();
              }
              catch (Exception)
              {
            // Reset SqlLimit did not work, connection is hosed.
            Connection.Abort();
            throw new MySqlException(ex.Message, true, ex);
              }

              // if we caught an exception because of a cancel, then just return null
              if (ex.IsQueryAborted)
            return null;
              if (ex.IsFatal)
            Connection.Close();
              if (ex.Number == 0)
            throw new MySqlException(Resources.FatalErrorDuringExecute, ex);
              throw;
            }
            finally
            {
              if (connection != null)
              {
            if (connection.Reader == null)
            {
              // Something went seriously wrong,  and reader would not
              // be able to clear timeout on closing.
              // So we clear timeout here.
              ClearCommandTimer();
            }
            if (!success)
            {
              // ExecuteReader failed.Close Reader and set to null to
              // prevent subsequent errors with DataReaderOpen
              ResetReader();
            }
              }
            }
              }
        }
예제 #9
0
 public virtual bool ExecuteReader(string sql, CommandBehavior behavior, ref MySqlDataReader returnValue)
 {
   return false;
 }
예제 #10
0
    public bool ExecuteReader(string sql, CommandBehavior behavior, ref MySqlDataReader returnValue)
    {
      if (insideInterceptor) return false;
      insideInterceptor = true;

      bool handled = false;

      foreach (BaseCommandInterceptor bci in interceptors)
        handled |= bci.ExecuteReader(sql, behavior, ref returnValue);

      insideInterceptor = false;
      return handled;
    }
예제 #11
0
파일: Driver.cs 프로젝트: BjkGkh/R106
    protected virtual void Dispose(bool disposing)
    {
      // Avoid cyclic calls to Dispose.
      if (disposeInProgress)
        return;

      disposeInProgress = true;

      try
      {
        ResetTimeout(1000);
        if (disposing)
          handler.Close(isOpen);
        // if we are pooling, then release ourselves
        if (connectionString.Pooling)
          MySqlPoolManager.RemoveConnection(this);
      }
      catch (Exception)
      {
        if (disposing)
          throw;
      }
      finally
      {
        reader = null;
        isOpen = false;
        disposeInProgress = false;
      }
    }