Room数据库迁移：新增数据表的实体类创建技术问询

Hey there! Let's break down your ProjectDimension entity design and walk through the Room migration steps for adding this new table. Here's my guidance:

Your entity is off to a solid start, but let's refine it for clarity and robustness:

• Explicit Column Names
  I recommend adding explicit name parameters to your @ColumnInfo annotations. While Room automatically converts camelCase fields to snake_case in the database, explicit naming avoids unexpected behavior and makes your schema easier to read:

  @ColumnInfo(name = "project_id") 
  private long projectId;
  @ColumnInfo(name = "name") 
  private String name;
  

• Complete Field Types
  Your code cuts off at @ColumnInfo private St...—make sure every field has a clear, valid type (e.g., String type, int value). Room relies on this to generate the correct table schema, so incomplete types will cause compilation or runtime errors.

• Accessibility & Getters/Setters
  While Room can use reflection to access private fields, it's better practice to add public getters and setters (or use Lombok's @Data annotation) for your fields. This makes your entity usable across your app's business logic without relying on reflection hacks.

• Primary Key Best Practices
  Your dimensionId setup with @PrimaryKey(autoGenerate = true) is correct. A quick reminder: when inserting a new ProjectDimension, set dimensionId to 0 and Room will automatically generate a unique, auto-incrementing ID. If you manually set a non-zero value, Room will use it (just ensure it's unique to avoid conflicts).

• Foreign Key & Index Validation
  Great call adding onDelete = ForeignKey.CASCADE—this ensures deleting a Project will automatically clean up related ProjectDimension records, preventing orphaned data. The projectId_index you added will also speed up queries filtering by projectId, which is critical for performance with large datasets.

Adding a new table is a straightforward migration, but follow these steps carefully to avoid data loss:

1. Increment the Database Version
   Update the version number in your RoomDatabase subclass's @Database annotation. If your previous version was 1, bump it to 2:

   @Database(entities = {Project.class, ProjectDimension.class}, version = 2)
   public abstract class AppDatabase extends RoomDatabase {
       // Your DAO definitions here
   }
   

2. Create a Migration Class
   Define a Migration class that tells Room how to upgrade from the old version to the new one. The SQL must exactly match your entity's structure:

   static final Migration MIGRATION_1_2 = new Migration(1, 2) {
       @Override
       public void migrate(@NonNull SupportSQLiteDatabase database) {
           // Replace `type` with your actual incomplete field's name/type
           database.execSQL("CREATE TABLE IF NOT EXISTS `ProjectDimension` (" +
                   "`dimensionId` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," +
                   "`projectId` INTEGER NOT NULL," +
                   "`name` TEXT," +
                   "`type` TEXT," +
                   "FOREIGN KEY(`projectId`) REFERENCES `Project`(`projectId`) ON DELETE CASCADE," +
                   "INDEX `projectId_index`(`projectId`))");
       }
   };
   

   • Use IF NOT EXISTS as a safety net to avoid errors if the table somehow already exists.
   • Double-check column names, types, and constraints match your entity exactly.

3. Register the Migration with Room
   Add your migration to the database builder. Skip this step, and Room will destroy your old database and create a new one—losing all existing data:

   AppDatabase db = Room.databaseBuilder(context.getApplicationContext(),
           AppDatabase.class, "app-database")
           .addMigrations(MIGRATION_1_2)
           .build();
   

4. Test the Migration
   Always test migrations with real data:

   • Install the old version of your app, add some Project records, then update to the new version.
   • Verify old Project data is intact, the ProjectDimension table exists, and deleting a Project removes its related dimensions.

5. Add DAO Methods
   Don't forget to create a DAO for your new table to interact with it:

   @Dao
   public interface ProjectDimensionDao {
       @Insert
       long insert(ProjectDimension dimension);
   
       @Query("SELECT * FROM ProjectDimension WHERE projectId = :projectId")
       List<ProjectDimension> getDimensionsByProjectId(long projectId);
   
       @Delete
       void delete(ProjectDimension dimension);
   }
   

   Then add the DAO to your AppDatabase subclass:

   public abstract ProjectDimensionDao projectDimensionDao();
   

• Mismatched SQL & Entity: Even a small difference (e.g., a missing NOT NULL constraint) will cause Room to throw an IllegalStateException on database open.
• Nullable Fields: If a field like name is nullable, don't add NOT NULL to its SQL column unless you intend it to be required.
• Auto-Migrations (Room 2.4+): For simple changes like adding a table, you can use Room's auto-migration feature by adding autoMigrations = @AutoMigration(from = 1, to = 2) to your @Database annotation. Always verify auto-generated migrations work as expected, though.

内容的提问来源于stack exchange，提问作者Gem Seeker