public void DeleteUser(int id)
 {
     try
     {
         connection.OpenConnection();
         connection.BeginTransaction();
         DbCommand command = new DbCommand("DELETE FROM Users WHERE Id = @id;");
         command.Parameters = new SqlParameter[1];
         command.Parameters[0] = new SqlParameter("id", id);
         command.Type = DbCommand.DbCommandType.DELETE;
         connection.ExecNonQuery(command);
         if (UserCollection != null)
         {
             UserCollection.Remove(UserCollection.Find(x => x.Id == id));
         }
         ReassignTasks(id);
         connection.CommitTransaction();
     }
     catch (Exception e)
     {
         connection.RollbackTransaction();
         Logger.Instance.WriteToLog(e.StackTrace);
         throw;
     }
     finally
     {
         connection.CloseConnection();
     }
 }

 public void AddParameter(DbCommand command, string name, object value)
 {
     DbParameter param = command.CreateParameter();
         param.ParameterName = name;
         param.Value = value ?? (object)DBNull.Value;
         command.Parameters.Add(param);
 }

 protected override bool SameNumberOfParametersAndValues(DbCommand command, object[] values)
 {
     int returnParameterCount = 0;
     int numberOfParametersToStoredProcedure = command.Parameters.Count - returnParameterCount;
     int numberOfValuesProvidedForStoredProcedure = values.Length;
     return numberOfParametersToStoredProcedure == numberOfValuesProvidedForStoredProcedure;
 }

 public void AddUser(IUser user)
 {
     try
     {
         connection.OpenConnection();
         DbCommand command = new DbCommand("INSERT INTO Users (Login, Password, Name, Surname, Email, IsActive, UserType) VALUES (@login, @password, @name, @surname, @email, @isactive, @usertype);");
         command.Parameters = new SqlParameter[7];
         command.Parameters[0] = new SqlParameter("login", user.Login);
         command.Parameters[1] = new SqlParameter("password", user.Password);
         command.Parameters[2] = new SqlParameter("name", user.Name);
         command.Parameters[3] = new SqlParameter("surname", user.Surname);
         command.Parameters[4] = new SqlParameter("email", user.Email);
         command.Parameters[5] = new SqlParameter("isactive", user.IsActive.ToString());
         command.Parameters[6] = new SqlParameter("usertype", (int)user.UserType);
         command.Type = DbCommand.DbCommandType.INSERT;
         connection.ExecNonQuery(command);
         //collection doesn't contain user Id here;
         UserCollection = null;
     }
     catch (Exception e)
     {
         Logger.Instance.WriteToLog(e.StackTrace);
         throw;
     }
     finally
     {
         connection.CloseConnection();
     }
 }

 public void DeleteRisk(int id)
 {
     try
     {
         connection.OpenConnection();
         DbCommand command = new DbCommand("DELETE FROM Risks WHERE Id = @id;");
         command.Parameters = new SqlParameter[1];
         command.Parameters[0] = new SqlParameter("id", id);
         command.Type = DbCommand.DbCommandType.DELETE;
         connection.ExecNonQuery(command);
         if (RiskCollection != null)
         {
             RiskCollection.Remove(RiskCollection.Find(x => x.Id == id));
         }
     }
     catch (Exception e)
     {
         Logger.Instance.WriteToLog(e.StackTrace);
         throw;
     }
     finally
     {
         connection.CloseConnection();
     }
 }

 public void SetParameter(DbCommand cmd, string name, object value)
 {
     if (!cmd.Parameters.Contains(name)) {
         throw new ArgumentException($"Parameter {name} not declared.");
     }
     cmd.Parameters[name].Value = value;
 }

        public void Run(object o, EventArgs e)
        {
            Photo[] photos = MainWindow.Toplevel.SelectedPhotos ();

            if (photos.Length == 0) {
                Console.WriteLine ("no photos selected, returning");
                return;
            }

            DateTime import_time = photos[0].Time;
            foreach (Photo p in photos)
                if (p.Time > import_time)
                    import_time = p.Time;

            RollStore rolls = App.Instance.Database.Rolls;
            Roll roll = rolls.Create(import_time);
            foreach (Photo p in photos) {
                DbCommand cmd = new DbCommand ("UPDATE photos SET roll_id = :roll_id " +
                                   "WHERE id = :id ",
                                   "roll_id", roll.Id,
                                   "id", p.Id);
                App.Instance.Database.Database.ExecuteNonQuery (cmd);
                p.RollId = roll.Id;
            }
            Console.WriteLine ("RetroactiveRoll done: " + photos.Length + " photos in roll " + roll.Id);
        }

 public BuilderData(DbCommand command, string tableName)
 {
     TableName = tableName;
     Command = command;
     Columns = new List<BuilderColumn>();
     Where = new List<BuilderColumn>();
     WhereString = new List<string>();
 }

        static void Main(string[] args)
        {
            var command = new DbCommand(new OracleConnection("oracle"), "SaveChanges()" );
            command.Execute();

            var command1 = new DbCommand(new SqlConnection("SQL"), "Clear()" );
            command1.Execute();
        }

 public override void AddParameter(DbCommand command, string name, DbType dbType, int size,
     ParameterDirection direction, bool nullable, byte precision, byte scale, string sourceColumn, DataRowVersion sourceVersion,
     object value)
 {
     DbParameter parameter = this.CreateParameter(name, dbType, size,
         direction, nullable, precision, scale, sourceColumn, sourceVersion, value);
     command.Parameters.Add(parameter);
 }

 protected static DbParameter AddParameter(DbCommand cmd, string name, object val)
 {
     DbParameter p = cmd.CreateParameter ();
         p.ParameterName = name;
         p.Value = val;
         cmd.Parameters.Add (p);
         return p;
 }

        private static void PrepareCommand(DbCommand cmd, MySqlConnection conn, CommandType cmdType, string cmdText)
        {
            if (conn.State != ConnectionState.Open)
                conn.Open();

            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            cmd.CommandType = cmdType;
        }

        internal EasylinkCommand(DbCommand command, string schemaName)
        {
            _command = command;

            _schemaName = schemaName;

            Sqls = new List<string>();

        }

 public DataTable ExecuteTable(DbCommand cmd)
 {
     using (DataSet st = new DataSet())
         {
             DbDataAdapter ap = CreateDataAdapter();
             ap.SelectCommand = cmd;
             ap.Fill(st);
             return st.Tables[0];
         }
 }

 public int DeclareParameter(DbCommand cmd, string name, DbType type)
 {
     if (cmd.Parameters.Contains(name)) {
         throw new ArgumentException($"Parameter {name} already declared.");
     }
     DbParameter param = cmd.CreateParameter();
     param.ParameterName = name;
     param.DbType = type;
     return cmd.Parameters.Add(param);
 }

        /// <summary>
        /// 여러 ResultSet을 반환할 수 있으므로, DataTable의 컬렉션으로 반환합니다.
        /// </summary>
        public override IList<DataTable> ExecuteDataTableAsList(DbCommand cmd, int firstResult, int maxResults,
                                                                params IAdoParameter[] parameters) {
            cmd.ShouldBeInstanceOf<MySqlCommand>("cmd");

            return With.TryFunctionAsync(() => Db.ExecuteDataTableAsListAsync((MySqlCommand)cmd,
                                                                              firstResult,
                                                                              maxResults,
                                                                              parameters)
                                                   .Result,
                                         () => new List<DataTable>());
        }

        /// <summary>
        /// <paramref name="cmd"/>를 실행하여, 결과를 DataSet으로 반환합니다.
        /// </summary>
        /// <param name="cmd">실행할 <see cref="DbCommand"/> instance.</param>
        /// <param name="firstResult">첫번째 레코드의 인덱스 (0부터 시작)</param>
        /// <param name="maxResults">최대 레코드 수 (0 이면 무시하고, 마지막 레코드까지 가져온다</param>
        /// <param name="parameters">collectio of parameters of Command</param>
        /// <returns>결과 셋이 담긴 DataSet</returns>
        public override DataSet ExecuteDataSet(DbCommand cmd, int firstResult, int maxResults, params IAdoParameter[] parameters) {
            cmd.ShouldNotBeNull("cmd");

            var result = new DataSet();

            var tables = ExecuteDataTableAsList(cmd, firstResult, maxResults, parameters);
            if(tables != null)
                result.Tables.AddRange(tables.ToArray());

            return result;
        }

 public int ExecuteNonQuery(DbCommand cmd)
 {
     DbConnection conn = null;
     try {
         conn = this.GetOpenConnection();
         cmd.Connection = conn;
         return cmd.ExecuteNonQuery();
     } finally {
         this.ReleaseConnection(conn);
     }
 }

 protected override void AddParameter(DbCommand command, QueryParameter parameter, object value)
 {
     DbQueryType sqlType = (DbQueryType)parameter.QueryType;
     if (sqlType == null)
         sqlType = (DbQueryType)this.provider.Language.TypeSystem.GetColumnType(parameter.Type);
     var p = ((MySqlCommand)command).Parameters.Add(parameter.Name, ToMySqlDbType(sqlType.SqlDbType), sqlType.Length);
     if (sqlType.Precision != 0)
         p.Precision = (byte)sqlType.Precision;
     if (sqlType.Scale != 0)
         p.Scale = (byte)sqlType.Scale;
     p.Value = value ?? DBNull.Value;
 }

 public IDataReader ExecuteReader(DbCommand cmd)
 {
     DbConnection conn = null;
     try {
         conn = this.GetOpenConnection();
         cmd.Connection = conn;
         CommandBehavior behavior = this.IsSharedConnection() ? CommandBehavior.Default : CommandBehavior.CloseConnection;
         return cmd.ExecuteReader(behavior);
     } catch {
         ReleaseConnection(conn);
         throw;
     }
 }