studio - Actualizar algún campo específico de una entidad en Android Room

room android example

Question

Estoy usando la biblioteca de persistencia de la sala de Android para mi nuevo proyecto. Quiero actualizar algún campo de tabla. He intentado como en mi Dao -

// Method 1:

@Dao
public interface TourDao {
    @Update
    int updateTour(Tour tour);
}

Pero cuando trato de actualizar usando este método, actualiza todos los campos de la entidad donde coincide con el valor de la clave primaria del objeto de viaje. He usado @Query

// Method 2:

@Query("UPDATE Tour SET endAddress = :end_address WHERE id = :tid")
int updateTour(long tid, String end_address);

Está funcionando, pero habrá muchas consultas en mi caso porque tengo muchos campos en mi entidad. Quiero saber cómo puedo actualizar algún campo (no todos) como el Method 1 donde id = 1; (id es la clave primaria de generación automática).

// Entity:

@Entity
public class Tour {
    @PrimaryKey(autoGenerate = true)
    public long id;
    private String startAddress;
    private String endAddress;
    //constructor, getter and setter
}

Answer 1

Quiero saber cómo puedo actualizar algún campo (no todos) como el método 1 donde id = 1

Use @Query , como lo hizo en el Método 2.

es una consulta demasiado larga en mi caso porque tengo muchos campos en mi entidad

Entonces tenga entidades más pequeñas. O bien, no actualice los campos individualmente, sino que tenga interacciones más generales con la base de datos.

IOW, no hay nada en la habitación que haga lo que buscas.

Answer 2

De acuerdo con los documentos de actualización de SQLite :

<!-- language: lang-java -->
@Query("UPDATE tableName SET 
    field1 = :value1,
    field2 = :value2, 
    ...
    //some more fields to update
    ...
    field_N= :value_N
    WHERE id = :id)

int updateTour(long id, 
               Type value1, 
               Type value2, 
               ... ,
               // some more values here
               ... ,
               Type value_N);

Ejemplo:

Entidad:

@Entity(tableName = "orders")
public class Order {

@NonNull
@PrimaryKey
@ColumnInfo(name = "order_id")
private int id;

@ColumnInfo(name = "order_title")
private String title;

@ColumnInfo(name = "order_amount")
private Float amount;

@ColumnInfo(name = "order_price")
private Float price;

@ColumnInfo(name = "order_desc")
private String description;

// ... methods, getters, setters
}

Dao:

@Dao
public interface OrderDao {

@Query("SELECT * FROM orders")
List<Order> getOrderList();

@Query("SELECT * FROM orders")
LiveData<List<Order>> getOrderLiveList();

@Query("SELECT * FROM orders WHERE order_id =:orderId")
LiveData<Order> getLiveOrderById(int orderId);

/**
* Updating only price
* By order id
*/
@Query("UPDATE orders SET order_price=:price WHERE order_id = :id")
void update(Float price, intid);

/**
* Updating only amount and price
* By order id
*/
@Query("UPDATE orders SET order_amount = :amount, price = :price WHERE order_id =:id")
void update(Float amount, Float price, int id);

/**
* Updating only title and description
* By order id
*/
@Query("UPDATE orders SET order_desc = :description, order_title= :title WHERE order_id =:id")
void update(String description, String title, int id);

@Update
void update(Order order);

@Delete
void delete(Order order);

@Insert(onConflict = REPLACE)
void insert(Order order);
}

Answer 3

Si necesita actualizar la información del usuario para un ID de usuario específico "x",

1. necesita crear una clase dbManager que inicialice la base de datos en su constructor y actúe como mediador entre su viewModel y DAO, y también.

2. ViewModel inicializará una instancia de dbManager para acceder a la base de datos. El código debería verse así:

      @Entity
       class User{
       @PrimaryKey
       String userId;
       String username;
       }
   
       Interface UserDao{
       //forUpdate
       @Update
       void updateUser(User user)
       }
   
       Class DbManager{
       //AppDatabase gets the static object o roomDatabase.
       AppDatabase appDatabase;
       UserDao userDao;
       public DbManager(Application application ){
       appDatabase = AppDatabase.getInstance(application);
   
       //getUserDao is and abstract method of type UserDao declared in AppDatabase //class
       userDao = appDatabase.getUserDao();
       } 
   
       public void updateUser(User user, boolean isUpdate){
       new InsertUpdateUserAsyncTask(userDao,isUpdate).execute(user);
       }
   
   
   
       public static class InsertUpdateUserAsyncTask extends AsyncTask<User, Void, Void> {
   
   
        private UserDao userDAO;
        private boolean isInsert;
   
        public InsertUpdateBrandAsyncTask(BrandDAO userDAO, boolean isInsert) {
          this. userDAO = userDAO;
          this.isInsert = isInsert;
        }
   
        @Override
        protected Void doInBackground(User... users) {
          if (isInsert)
       userDAO.insertBrand(brandEntities[0]);
          else
       //for update
       userDAO.updateBrand(users[0]);
       //try {
       //  Thread.sleep(1000);
       //} catch (InterruptedException e) {
       //  e.printStackTrace();
       //}
          return null;
        }
         }
       }
   
        Class UserViewModel{
        DbManager dbManager;
        public UserViewModel(Application application){
        dbmanager = new DbMnager(application);
        }
   
        public void updateUser(User user, boolean isUpdate){
        dbmanager.updateUser(user,isUpdate);
        }
   
        }
   
   
   
   
   Now in your activity or fragment initialise your UserViewModel like this:
   
   UserViewModel userViewModel = ViewModelProviders.of(this).get(UserViewModel.class);

   Luego, simplemente actualice su elemento de usuario de esta manera, suponga que su ID de usuario es 1122 y nombre de usuario es "xyz", que debe cambiarse a "zyx".

   Obtenga un userItem de id 1122 Objeto de usuario

User user = new user();
 if(user.getUserId() == 1122){
   user.setuserName("zyx");
   userViewModel.updateUser(user);
 }

Este es un código en bruto, espero que te ayude.

Codificación feliz

Answer 4

Tal vez puedas probar esto, pero el rendimiento será un poco peor (o más):

@Dao
public abstract class TourDao {

    @Query("SELECT * FROM Tour WHERE id == :id")
    public abstract Tour getTour(int id);

    @Update
    public abstract int updateTour(Tour tour);

    public void updateTour(int id, String end_address) {
        Tour tour = getTour(id);
        tour.end_address = end_address;
        updateTour(tour);
    }
}