we already created sqlite database. this database we stored 500 000 up data but now we want to convert those data on room database. How to stored those all data in room database?
Migrate from SQLite to Room
Example : 😎
SQLiteOpenHelper implementation
User.java
public class User {
private int uId;
private String uName;
private String uContact;
public User() {
}
public User(int id, String name, String number){
this.uId = id;
this.uName = name;
this.uContact= number;
};
//getters setters left out for brevity
}
UserDbHelper.java
public class UserDbHelper extends SQLiteOpenHelper {
private static final int DATABASE_VERSION = 1;
// Database Name
private static final String DATABASE_NAME = "userDB";
// user table name
private static final String TABLE_USERS = "users";
// user Table Columns names
private static final String USER_ID = "user_id";
private static final String USER_NAME = "user_name";
private static final String USER_PH_NO = "user_contact";
public UserDbHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
#Override
public void onCreate(SQLiteDatabase db) {
//create the table if not yet created
String CREATE_USER_TABLE = "CREATE TABLE " + TABLE_USERS + "("
+ USER_ID + " INTEGER PRIMARY KEY," + USER_NAME + " TEXT,"
+ USER_PH_NO + " TEXT" + ")";
db.execSQL(CREATE_USER_TABLE);
}
#Override
public void onUpgrade(SQLiteDatabase db, int i, int i1) {
// Drop older table if existed
db.execSQL("DROP TABLE IF EXISTS " + TABLE_USERS);
// Create tables again
onCreate(db);
}
public void addUser(User user){
//Add new user to database
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(USER_NAME, user.getUName()); // Contact Name
values.put(USER_PH_NO, user.getUContact()); // Contact Phone
values.put(USER_ID, user.getUId());
// Inserting Row
db.insert(TABLE_USERS, null, values);
db.close(); // Closing database connection
}
public User getUser(int id){
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.query(TABLE_USERS, new String[] { USER_ID,
USER_NAME, USER_PH_NO }, USER_ID + "=?",
new String[] { String.valueOf(id) }, null, null, null, null);
if (cursor != null)
cursor.moveToFirst();
User contact = new User(Integer.parseInt(cursor.getString(0)),
cursor.getString(1), cursor.getString(2));
return contact;
}
}
add data
//get database instance
UserDbHelper userDbHelper = new UserDbHelper(this);
//add couple of users
userDbHelper.addUser(new User(1,"Hulk","11-445-9999"));
userDbHelper.addUser(new User(2,"Dominic","11-445-9999"));
And fetch the users using this.
User extractedUser = userDbHelper.getUser(1);
Migrating to Room:
User.java
#Entity
public class User {
#PrimaryKey
private int uId;
private String uName;
private String uNumber;
public User() {
}
#Ignore
public User(int id, String name, String number){
this.uId = id;
this.uName = name;
this.uNumber= number;
};
//add all the getters and setters here
}
UserDAO.java
#Dao
public interface UserDAO {
#Insert(onConflict = REPLACE)
void insertUser(User user);
#Query("SELECT * FROM User")
List<User> getUsers();
}
UserDB.java
#Database (entities = {User.class},version = 2)
public abstract class UserDB extends RoomDatabase {
public abstract UserDAO userDAO();
}
Migration instance
final Migration MIGRATION_1_2 = new Migration(1, 2) {
#Override
public void migrate(SupportSQLiteDatabase database) {
// Since we didn't alter the table, there's nothing else to do here.
}
};
//create db
final UserDB userDB = Room.databaseBuilder(this
, UserDB.class
, "userDB")
.addMigrations(MIGRATION_1_2)
.build();
//inserting and accessing data using DAO
//this operations needs to be performed on thread other than main thread
userDB.userDAO().insertUser(new User123(5,"Wowman", "888888888"));
userDB.userDAO().insertUser(new User123(6,"Captain", "888888888"));
User user = userDB.userDAO().getUsers().get(0);
Table
#ColumnInfoname(name="user_id")
private int uId;
For full demo https://github.com/amit-bhandari/RoomSamples
This is a potentially difficult task as Room has quite specific requirements for column definitions (the dreaded expected .... found ....).
In short Room can only have column types that are one off INTEGER, REAL, TEXT. BLOB. (note that Room does not support the NUMERIC type).
Furthermore column constraints also have to suit what Room expects.
I would suggest that the way to go is to create the #Entity annotated classes (one per table) with suitable members/fields, that matches the original database as closely as possible
Each #Entity annotated class MUST have a PRIMARY KEY either a single member/field annotated with #PrimaryKey or the primary key can be specified using the primaryKeys parameter of the #Entity annotation.
I would suggest after creating the first #Entity annotated class to then create the #Database annotated abstract class that extends the RoomDatabase class. Noting that the entities parameter should be a list of the #Entity annotated class (i.e. indicating which classes/tables are to be used for the database).
After the creation of each (at least at first) I would suggest compiling the project, so as to limit the possible issues that may be encountered.
Once you have all the #Entity annotated classes then you can consider the migration aspect.
As you have pre-existing data you will want to include the original database as an asset. Room can then copy this database from the asset via the createFromAsset method. However, there is a high chance that the tables will need converting to suit Room.
You can convert the tables either prior to creating the asset file or you could convert the tables via the prePackagedDatabaseCallback. I would suggest that the former is simpler as you can use one of the available SQLite Tools.
Obviously you need to know what needs to be converted. Rather to try to explain the rules. Room, after successfully compiling the project, generates the SQL that it uses to create the tables (and indexes and views)
triggers are not something that Room caters for (an exception being for FTS), so if you have triggers then you could add them as part of the conversion.
In the Android View after compiling you will see that in Java(generated) there will be class that is the same as the #Database annotated class but suffixed with Impl. In this class there will be a method createAllTables. This includes the SQL for all of the tables and indexes (ignore tables that start with sqlite_, android_ or room_ as these are system tables and will be created as required).
Basically you create these tables and then copy the data from original. Obviously one set of tables MUST have different names, after the data has been coped you then drop the original tables ending up with the new tables with the original names.
Thus at some stage you will have to rename a set of tables.
You can either
create the new tables different name, copy the data, drop the original tables and then rename the new tables, or
rename the original tables, create the new tables, copy the data and drop the renamed original tables
There is a good chance that you could do the copies using a simple INSERT SELECT. e.g. INSERT INTO new_table SELECT * FROM original_table;
however complexities can arise, again sometimes Room will have expectations that may not suit exactly.
Simple Example
This is based upon a data base with three tables:-
1) The establishment table with 5 columns:-
the establishment_id, a unique integer value that is the primary key.
the establishment_name, which has the name of the establishmnet as a text/string value and has the UNIQUE constraint.
the country, a text/string value.
the state, a text/string value.
the city a text/string value.
However, the column types use the flexibility of SQLite's column types to demonstrate (wrongly or rightfully is debatable and that debate is beyond the scope of the answer).
the DDL being
:-
CREATE TABLE establishment (
establishment_id INTEGER PRIMARY KEY,
establishment_name the_name_of_the_establishment UNIQUE,
country unusualcolumntype,
state VARCHAR(16),
city charvar(32)
);
The table is populated with according to:-
and
2) The classroom table with 3 columns:-
the classroom_id, a unique integer value that is the primary key.
the clasroom_name, a text/string value that has the UNQIUE constraint.
the classroom_capacity, an integer value.
the DDL being
:-
CREATE TABLE classroom (
classroom_id INTEGER PRIMARY KEY,
classroom_name UNIQUE,
classroom_capacity
);
the table is populated according to:-
finally
3) the establishment_classroom_map, an associative/mapping/reference (an various other terms) table that caters for a many-many relationship between establishments and rooms (albeit it unlikely that the same room would be used by multiple establishments). The table has 2 columns:-
the establishment_id_map, an integer value which MUST be an existing value in the establishment_id column of the establishment table (aka a Foreign Key).
the classroom_id_map, likewise an integer value which MUST be an existing value in the classrom_id column of the classroom table, again a Foreign Key.
the columns form a composite primary key
additionally, to add some complexity, the classroom_id_map column is also indexed.
the DDL being
:-
CREATE TABLE establishment_classroom_map (
establishment_id_map INTEGER REFERENCES establishment(establishment_id) ON DELETE CASCADE ON UPDATE CASCADE,
classroom_id_map INTEGER REFERENCES classroom(classroom_id) ON DELETE CASCADE ON UPDATE CASCADE,
PRIMARY KEY (establishment_id_map,classroom_id_map)
);
CREATE INDEX idx01_establishmentclassroommap_classroom ON establishment_classroom_map (classroom_id_map);
the table is populated as per:-
Using the following query:-
SELECT
establishment.establishment_name,
establishment.city
||','||establishment.state
||','||establishment.country AS establisment_address,
classroom.classroom_name, classroom.classroom_capacity
FROM establishment
JOIN establishment_classroom_map ON establishment.establishment_id = establishment_classroom_map.establishment_id_map
JOIN classroom ON establishment_classroom_map.classroom_id_map = classroom.classroom_id
;
results in:-
This is the Original Database to be converted.
Step1 - Creating the Room #Entity annotated classes (3 of them).
1.a in Android Studio a new empty Kotlin project is created (in this case SO74298106MigratePreRoomDatabase) and the minimal Room dependencies are added via File/Project Structure/Dependencies that result in:-
implementation 'androidx.room:room-ktx:2.5.0-beta01'
implementation 'androidx.room:room-runtime:2.5.0-beta01'
kapt 'androidx.room:room-compiler:2.5.0-beta01'
1.b for brevity and convenience a single file named DBStuff.kt is created (New Kotlin Class/File)
1.c The DBStuff file is changed from nothing to :-
const val ESTABLISHMENT_TABLE_NAME = "establishment"
const val ESTABLISHMENT_TABLE_ID_COLUMN_NAME = ESTABLISHMENT_TABLE_NAME + "_id"
const val ESTABLISHMENT_TABLE_NAME_COLUMN_NAME = ESTABLISHMENT_TABLE_NAME + "_name"
const val ESTABLISHMENT_TABLE_COUNTRY_COLUMN_NAME = "country"
const val ESTABLISHMENT_TABLE_STATE_COLUMN_NAME = "state"
const val ESTABLISHMENT_TABLE_CITY_COLUMN_NAME = "city"
#Entity(
tableName = ESTABLISHMENT_TABLE_NAME,
indices = [
Index(value = [ESTABLISHMENT_TABLE_NAME_COLUMN_NAME], unique = true)
]
)
data class Establishment(
/* as integer type AND annotated with #Primary key then an alias of the rowid */
/* note in theory rowid's can exceed the capacity of an Int, hence Long used */
/* the default value of null, is interpreted by room as not to supply a value and this the value will be generated */
/* it is inefficient to use AutoGenerate = true */
#PrimaryKey
#ColumnInfo(name = ESTABLISHMENT_TABLE_ID_COLUMN_NAME)
var establishment_id: Long?=null,
/* Note the single use of type String for all the various column types in the original */
#ColumnInfo(name = ESTABLISHMENT_TABLE_NAME_COLUMN_NAME)
var name: String, /* no ? so cannot be null */
#ColumnInfo(name = ESTABLISHMENT_TABLE_COUNTRY_COLUMN_NAME)
var country: String,
#ColumnInfo(name = ESTABLISHMENT_TABLE_STATE_COLUMN_NAME)
var state: String,
#ColumnInfo(name = ESTABLISHMENT_TABLE_CITY_COLUMN_NAME)
var city: String
)
#Database(entities = [Establishment::class], exportSchema = false, version = 1)
abstract class TheDatabase: RoomDatabase() {
}
The constants are not required but suggested as a single point for the column, table and database names.
Room will by default use the field/member/class name for the column and table names but you can change these as has been shown via the #ColumnInfo and for tablenames the #Entity annotation.
What Room doesn't cater for is the column's UNIQUE constraint. So to enforce the UNIQUEness a unique index has been specified for the establishment_name column.
Note the #Database annotated class with the Establishment class listed in the entities parameter of the #Database annotation, otherwise no use is yet made of the database. However, if at this stage the project is compiled then:-
i.e. Room has kindly let us know what it expects the exact schema to be.
i.e. how Room interprets the #Entity annotated Establishment class.
Room expects the establishment table to be exactly:-
CREATE TABLE IF NOT EXISTS `establishment` (
`establishment_id` INTEGER,
`establishment_name` TEXT NOT NULL,
`country` TEXT NOT NULL,
`state` TEXT NOT NULL,
`city` TEXT NOT NULL,
PRIMARY KEY(`establishment_id`)
)
not quite correct as establisment_id INTEGER PRIMARY KEY will be consider as the above (noting that the column level use of PRIMARY KEY cannot be used for a composite primary key).
The above does have a potential issue in that all columns have the NOT NULL constraint. If there are null values in the original data then constraint conflicts will result unless action is taken to either ignore (INSERT OR IGNORE INTO ....) or the column is converted e.g. '.... SELECT coalesce(the_column,'default_value'), .... '
as we can see the original data above does not contain nulls so this will not be an issue.
Onto the classroom table/#Entity annotated class, we add the following code:-
const val CLASSROOM_TABLE_NAME = "classroom"
const val CLASSROOM_TABLE_ID_COLUMN_NAME = CLASSROOM_TABLE_NAME + "_id"
const val CLASSROOM_TABLE_NAME_COLUMN_NAME = CLASSROOM_TABLE_NAME + "_name"
const val CLASSROOM_TABLE_CAPACITY_COLUMN_NAME = CLASSROOM_TABLE_NAME + "_capacity"
and
#Entity(
tableName = CLASSROOM_TABLE_NAME,
indices = [
Index(value = [CLASSROOM_TABLE_NAME_COLUMN_NAME], unique = true)
]
)
data class Classroom(
#PrimaryKey
#ColumnInfo(name = CLASSROOM_TABLE_ID_COLUMN_NAME)
var classroomId: Long?=null,
#ColumnInfo(name = CLASSROOM_TABLE_NAME_COLUMN_NAME)
var name: String,
#ColumnInfo(name = CLASSROOM_TABLE_CAPACITY_COLUMN_NAME)
var capacity: Int
)
and then change the #Database annotation to include the Classroom class in the entities parameter:-
#Database(entities = [Establishment::class,Classroom::class], exportSchema = false, version = 1)
and then compile and looking at the generated database class it now includes:-
_db.execSQL("CREATE TABLE IF NOT EXISTS `classroom` (`classroom_id` INTEGER, `classroom_name` TEXT NOT NULL, `classroom_capacity` INTEGER NOT NULL, PRIMARY KEY(`classroom_id`))");
_db.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS `index_classroom_classroom_name` ON `classroom` (`classroom_name`)");
onto the establishment_classroom_map** table. This is a little more complex as Room needs to be told about
the Foreign Keys and
the index on the classroom_id_map column (so access via the classroom is more efficient) and
the composite primary key
So the following code is added:-
const val ESTABLISHMENTCLASSROOMMAP_TABLE_NAME = "${ESTABLISHMENT_TABLE_NAME}_${CLASSROOM_TABLE_NAME}_map"
const val ESTABLISHMENTCLASSROOMMAP_TABLE_ESTABLISHMENTIDMAP_COLUMN_NAME = "${ESTABLISHMENT_TABLE_ID_COLUMN_NAME}_map"
const val ESTABLISHMENTCLASSROOMMAP_TABLE_CLASSROOMIDMAP_COLUMN_NAME = "${CLASSROOM_TABLE_ID_COLUMN_NAME}_map"
and
#Entity(
tableName = ESTABLISHMENTCLASSROOMMAP_TABLE_NAME,
foreignKeys = [
ForeignKey(
entity = Establishment::class,
parentColumns = [ESTABLISHMENT_TABLE_ID_COLUMN_NAME],
childColumns = [ESTABLISHMENTCLASSROOMMAP_TABLE_ESTABLISHMENTIDMAP_COLUMN_NAME],
onDelete = ForeignKey.CASCADE,
onUpdate = ForeignKey.CASCADE
),
ForeignKey(
entity = Classroom::class,
parentColumns = [CLASSROOM_TABLE_ID_COLUMN_NAME],
childColumns = [ESTABLISHMENTCLASSROOMMAP_TABLE_CLASSROOMIDMAP_COLUMN_NAME],
onDelete = CASCADE,
onUpdate = CASCADE
)
],
primaryKeys = [ESTABLISHMENTCLASSROOMMAP_TABLE_ESTABLISHMENTIDMAP_COLUMN_NAME, ESTABLISHMENTCLASSROOMMAP_TABLE_CLASSROOMIDMAP_COLUMN_NAME]
)
data class EstablishmentClassroomMap(
#ColumnInfo(name = ESTABLISHMENTCLASSROOMMAP_TABLE_ESTABLISHMENTIDMAP_COLUMN_NAME)
var establishment_id_map: Long,
#ColumnInfo(name = ESTABLISHMENTCLASSROOMMAP_TABLE_CLASSROOMIDMAP_COLUMN_NAME, index = true)
var classroom_id_map: Long
)
foreign keys and composite primary key are defined in the #Entity annotation
and
the index on the classroom_id_map column is defined in the #ColumnInfo annotation
After yet again amending the #Database annotation to now use entities = [Establishment::class,Classroom::class, EstablishmentClassroomMap::class] and then compiling the following is additionally generated:-
_db.execSQL("CREATE TABLE IF NOT EXISTS `establishment_classroom_map` (`establishment_id_map` INTEGER NOT NULL, `classroom_id_map` INTEGER NOT NULL, PRIMARY KEY(`establishment_id_map`, `classroom_id_map`), FOREIGN KEY(`establishment_id_map`) REFERENCES `establishment`(`establishment_id`) ON UPDATE CASCADE ON DELETE CASCADE , FOREIGN KEY(`classroom_id_map`) REFERENCES `classroom`(`classroom_id`) ON UPDATE CASCADE ON DELETE CASCADE )");
_db.execSQL("CREATE INDEX IF NOT EXISTS `index_establishment_classroom_map_classroom_id_map` ON `establishment_classroom_map` (`classroom_id_map`)");
Now the SQL for the creation of the tables that Room expects exists.
Step 2 Converting the original data to suit room.
IT IS STRONGLY SUGGESTED THAT THIS IS DONE USING A COPY OF THE ORIGINAL DATABASE OR THAT THE ORIGINAL DATABASE IS BACKED UP
This is probably best done using an SQLite tool (Navicat for SQlite used in this case). In short you generate and populate the tables created as per the generated SQl after successful compilation.
Here's the query used for the conversion (it includes the original query used above to display the joined data):-
/*
>>>>>>>>>> IMPORTANT <<<<<<<<<<
>>>>>>>>>> COMMENTED OUT AFTER FIRST RUN AS THEY WILL FAIL AFTER RUNNING ONCE <<<<<<<<<<
ALTER TABLE establishment_classroom_map RENAME TO original_establishment_classroom_map;
ALTER TABLE establishment RENAME TO original_establishment;
ALTER TABLE classroom RENAME TO original_classroom;
*/
/* FROM Generated Java (copied here as is so it can be copied from here):-
_db.execSQL("CREATE TABLE IF NOT EXISTS `establishment` (`establishment_id` INTEGER, `establishment_name` TEXT NOT NULL, `country` TEXT NOT NULL, `state` TEXT NOT NULL, `city` TEXT NOT NULL, PRIMARY KEY(`establishment_id`))");
_db.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS `index_establishment_establishment_name` ON `establishment` (`establishment_name`)");
_db.execSQL("CREATE TABLE IF NOT EXISTS `classroom` (`classroom_id` INTEGER, `classroom_name` TEXT NOT NULL, `classroom_capacity` INTEGER NOT NULL, PRIMARY KEY(`classroom_id`))");
_db.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS `index_classroom_classroom_name` ON `classroom` (`classroom_name`)");
_db.execSQL("CREATE TABLE IF NOT EXISTS `establishment_classroom_map` (`establishment_id_map` INTEGER NOT NULL, `classroom_id_map` INTEGER NOT NULL, PRIMARY KEY(`establishment_id_map`, `classroom_id_map`), FOREIGN KEY(`establishment_id_map`) REFERENCES `establishment`(`establishment_id`) ON UPDATE CASCADE ON DELETE CASCADE , FOREIGN KEY(`classroom_id_map`) REFERENCES `classroom`(`classroom_id`) ON UPDATE CASCADE ON DELETE CASCADE )");
_db.execSQL("CREATE INDEX IF NOT EXISTS `index_establishment_classroom_map_classroom_id_map` ON `establishment_classroom_map` (`classroom_id_map`)");
*/
/* Just in case the tables exist drop them (they shouldn't but if rerunning they will)*/
DROP TABLE IF EXISTS establishment_classroom_map;
DROP TABLE IF EXISTS establishment;
DROP TABLE IF EXISTS classroom;
CREATE TABLE IF NOT EXISTS `establishment` (
`establishment_id` INTEGER,
`establishment_name` TEXT NOT NULL,
`country` TEXT NOT NULL,
`state` TEXT NOT NULL,
`city` TEXT NOT NULL,
PRIMARY KEY(`establishment_id`)
);
CREATE UNIQUE INDEX IF NOT EXISTS `index_establishment_establishment_name` ON `establishment` (`establishment_name`);
CREATE TABLE IF NOT EXISTS `classroom` (
`classroom_id` INTEGER,
`classroom_name` TEXT NOT NULL,
`classroom_capacity` INTEGER NOT NULL,
PRIMARY KEY(`classroom_id`)
);
CREATE UNIQUE INDEX IF NOT EXISTS `index_classroom_classroom_name` ON `classroom` (`classroom_name`);
CREATE TABLE IF NOT EXISTS `establishment_classroom_map` (
`establishment_id_map` INTEGER NOT NULL,
`classroom_id_map` INTEGER NOT NULL,
PRIMARY KEY(
`establishment_id_map`,
`classroom_id_map`
),
FOREIGN KEY(`establishment_id_map`) REFERENCES `establishment`(`establishment_id`) ON UPDATE CASCADE ON DELETE CASCADE ,
FOREIGN KEY(`classroom_id_map`) REFERENCES `classroom`(`classroom_id`) ON UPDATE CASCADE ON DELETE CASCADE
);
INSERT /* OR IGNORE */ INTO establishment SELECT * FROM original_establishment;
INSERT /* OR IGNORE */ INTO classroom SELECT * FROM original_classroom;
INSERT /* OR IGNORE */ INTO establishment_classroom_map SELECT * FROM original_establishment_classroom_map;
/* MORE EFFICIENT IF LEFT TILL AFTER INSERTS BUT WILL NOT DETECT UNIQUE CONFLICTS */
CREATE INDEX IF NOT EXISTS `index_establishment_classroom_map_classroom_id_map` ON `establishment_classroom_map` (`classroom_id_map`);
SELECT
establishment.establishment_name,
establishment.city
||','||establishment.state
||','||establishment.country AS establisment_address,
classroom.classroom_name, classroom.classroom_capacity
FROM establishment
JOIN establishment_classroom_map ON establishment.establishment_id = establishment_classroom_map.establishment_id_map
JOIN classroom ON establishment_classroom_map.classroom_id_map = classroom.classroom_id
;
/* ONLY INTRODUCE WHEN FULLY CONFIDENT THAT THE CONVERSION WORKS
DROP TABLE IF EXISTS original_establishment_classroom_map;
DROP TABLE IF EXISTS original_establishment;
DROP TABLE IF EXISTS original_classroom;
*/
The end result (output from query) :-
Note as this is just a demo the original tables have not been dropped
The database should then be saved and closed.
Step 3 using the converted database
Copy and paste the database into the assets folder (you may have to create the assets folder, right click App/New/Directory/src/main/assets)
Create an #Dao annotated interface so that the database can be accessed easily. e.g.
#Dao
interface AllDao {
#Query("SELECT * FROM ${ESTABLISHMENT_TABLE_NAME}")
fun getAllEstablishments(): List<Establishment>
#Query("SELECT * FROM ${CLASSROOM_TABLE_NAME}")
fun getAllClassrooms(): List<Classroom>
#Query("SELECT * FROM ${ESTABLISHMENTCLASSROOMMAP_TABLE_NAME}")
fun getAllEstablishmentClassroomMaps(): List<EstablishmentClassroomMap>
}
Amend the #Database annotated class to include an abstract function to get an instance of the #Dao annotated class. You may wish to add a singleton to allow a single instance of the database to be retrieved rather than using Room's databaseBuilder method multiple times. Noting that you will be using the databaseBuilder's createFromAsset to copy the database from the assets folder when the database is first required (i.e. the very first time the App is run) so you could for example have:-
#Database(entities = [Establishment::class,Classroom::class, EstablishmentClassroomMap::class], exportSchema = false, version = 1)
abstract class TheDatabase: RoomDatabase() {
abstract fun getAllDao(): AllDao
companion object {
private var instance: TheDatabase? = null
fun getInstance(context: Context): TheDatabase {
if (instance == null) {
instance = Room.databaseBuilder(context, TheDatabase::class.java, "TheDatabase.db")
.allowMainThreadQueries()
.createFromAsset("TheDatabase.db")
.build()
}
return instance as TheDatabase
}
}
}
NOTE the string encoded in the createFromAsset this MUST match the file name of the copied database (which can be renamed to suit) e.g:-
Lastly to test some code is added in an activity to access the database (the copy from the assets folder will only be done if an attempt is made to actually access the database (getting an instance of the #Database annotated class WILL NOT access the database)) so for example:-
class MainActivity : AppCompatActivity() {
lateinit var db: TheDatabase
lateinit var dao: AllDao
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
db = TheDatabase.getInstance(this)
dao = db.getAllDao()
for (e in dao.getAllEstablishments()) {
Log.d("DBINFO_ESTAB","ID is ${e.establishment_id} name is ${e.name} etc")
}
for (c in dao.getAllClassrooms()) {
Log.d("DBINFO_CLS","ID is ${c.classroomId} name is ${c.name} etc")
}
for (ecm in dao.getAllEstablishmentClassroomMaps()) {
Log.d("DBINFO_ECM", "ESTID is ${ecm.establishment_id_map} CLSID is ${ecm.classroom_id_map}")
}
}
}
And when run the log contains:-
2022-11-04 14:04:22.436 D/DBINFO_ESTAB: ID is 100 name is Massachusetts Institute of Technology (MIT) etc
2022-11-04 14:04:22.436 D/DBINFO_ESTAB: ID is 110 name is Oxford University etc
2022-11-04 14:04:22.436 D/DBINFO_ESTAB: ID is 120 name is Cambridge University etc
2022-11-04 14:04:22.436 D/DBINFO_ESTAB: ID is 130 name is Hull University etc
2022-11-04 14:04:22.436 D/DBINFO_ESTAB: ID is 131 name is Imperial College etc
2022-11-04 14:04:22.439 D/DBINFO_CLS: ID is 200 name is RM001 etc
2022-11-04 14:04:22.439 D/DBINFO_CLS: ID is 210 name is RM002 etc
2022-11-04 14:04:22.439 D/DBINFO_CLS: ID is 220 name is LAB001 etc
2022-11-04 14:04:22.439 D/DBINFO_CLS: ID is 230 name is LAB002 etc
2022-11-04 14:04:22.441 D/DBINFO_ECM: ESTID is 100 CLSID is 200
2022-11-04 14:04:22.441 D/DBINFO_ECM: ESTID is 100 CLSID is 220
2022-11-04 14:04:22.441 D/DBINFO_ECM: ESTID is 110 CLSID is 210
2022-11-04 14:04:22.441 D/DBINFO_ECM: ESTID is 110 CLSID is 230
2022-11-04 14:04:22.441 D/DBINFO_ECM: ESTID is 120 CLSID is 220
2022-11-04 14:04:22.441 D/DBINFO_ECM: ESTID is 120 CLSID is 230
2022-11-04 14:04:22.441 D/DBINFO_ECM: ESTID is 130 CLSID is 200
2022-11-04 14:04:22.441 D/DBINFO_ECM: ESTID is 130 CLSID is 210
Using App inspection and the query from the conversion:-
I use Mybatis to access db, and some tables is sharding by id with hash algorithm.
I want to write a Mybatis intecepter to change table name automatic, it need to get the sharding column value.
Table Entity:
#Data
#TableName("m_user")
public class User {
#TableId(type = IdType.AUTO)
private Integer id;
private String name;
private Integer age;
}
UserMapper sql:
#Select("select * from m_user where id = #{id2} and name = #{name2};")
List<User> selectByIdAndName(Integer id2, String name2);
I use boundSql.getParameterObject() and boundSql.getParameterMappings() to check, but I can not make sure whether the sharding column id is in sql and then get the value of the sharding column.
ParameterMappings values and ParameterObject values are here:
parameter mapping:ParameterMapping{property='id2', mode=IN, javaType=class java.lang.Object, jdbcType=null, numericScale=null, resultMapId='null', jdbcTypeName='null', expression='null'}
parameter mapping:ParameterMapping{property='name2', mode=IN, javaType=class java.lang.Object, jdbcType=null, numericScale=null, resultMapId='null', jdbcTypeName='null', expression='null'}
params:{id2=1, param1=1, name2=name1, param2=name1}
The parameters are Mapper function parameters, but I need sharding column id and value, program can only get id2 or param1.
How to get the db column and value from Mybatis?
I have a table on Postgres that auto generates UUIDs, when I dd Customer::all(); on Laravel I get an array with "cs_id" => "d0402be5-e1ba-4cb2-a80c-5340b406e2c3" which is fine. When I loop or select one record with the only the cs_id the data it retuns 0,2,5 for the three records currently on the table which is incorrect data.
EDIT:
CREATE TABLE customers
(
cs_id character varying(255) NOT NULL DEFAULT gen_random_uuid(),
CONSTRAINT cs_customers_pkey PRIMARY KEY (cs_id),
}
On laravel
$customerData = Customer::where('cs_id','d0402be5-e1ba-4cb2-a80c-5340b406e2c3')->first();
dd($customerData['cs_id']);
For some reason Eloquent messes up there.
just add a getter and use it whenever you need the cs_id
public function getGuid()
{
return $this->attributes['cs_id'];
}
To use uuids auto-generated by the database, define your model as follows:
class Customer extends Model
{
// rename the id column (optional)
protected $primaryKey = 'cs_id';
// tell Eloquent that your id is not an integer
protected $keyType = 'string';
// do NOT set $incrementing to false
}
Then you can use all Eloquent's methods as you would with classic ids:
$customerData = Customer::findOrFail('d0402be5-e1ba-4cb2-a80c-5340b406e2c3');
Use Customer::findOrFail('d0402be5-e1ba-4cb2-a80c-5340b406e2c3');
to get the record matching that pk.
I'm assuming on top you have use App\Customer;
I'm new in Grails. I have a problem with generation association many to one and one to many between two tables. I'm using postgresql database.
Employee.groovy
class Employee {
String firstName
String lastName
int hoursLimit
Contact contact
Account account
Unit unit
char isBoss
static hasMany = [positionTypes:PositionType, employeePlans: EmployeePlan]
}
EmployeePlan.groovy
class EmployeePlan {
AcademicYear academicYear
HourType hourType
int hours
float weightOfSubject
Employee employee
static belongsTo = [SubjectPlan]
}
I'd like to have access from employee to list of employeePlans and access from EmployeePlan to Employee instance. Unfortunately GORM generates only two tables Employee and EmployeePlan with employee_id. I don't have third table which should have two columns employee_id and employee_plan_id. Could you help me ?
I think your setup is correct, as you write from Employee class you can access to a collection of EmployeePlan (take care, that if you don't explicitly define EmployeePlan like a List, it will be a Set by default) and from EmployeePlan you can access Employee.
If you need List, you can define it like that:
class Employee {
String firstName
String lastName
int hoursLimit
Contact contact
Account account
Unit unit
char isBoss
//explicitly define List
List<EmployeePlan> employeePlans
static hasMany = [positionTypes:PositionType, employeePlans: EmployeePlan]
}
But back to your question. You'd like to have join table between Employee and employeePlan, but why? Its not necessary, since you have bidirectional mapping with sets (unordered), grails will not create a join table. Can you explain why do you need it? In grails the references will be auto-populated, so I don't see any issue here.
If need to preserve order of employeePlans, then define it as List, shown above, and grails will create a join table with corresponding indexes.
have you read the ref-doc? it gives you the answer immediately:
class Person {
String firstName
static hasMany = [addresses: Address]
static mapping = {
table 'people'
firstName column: 'First_Name'
addresses joinTable: [name: 'Person_Addresses',
key: 'Person_Id',
column: 'Address_Id']
}
}
I have set of entity (POJO) classes, Each entity class will have one property stopDate , which is type of Date.
#Entity
#Table(name="ORG")
public class Organization extends PersistentObjImpl {
private Long odbid; //ODBID NUMBER(11) i.e. Primary Key
private String actionFeedReqInd;
private String alternateName;
private Date stopDate; //STOP_DATE NOT NULL DATE
#Temporal(TemporalType.DATE)
#Column(name="STOP_DATE", nullable=false)
public Date getStopDate() {
return stopDate;
}
public void setStopDate(Date stopDate) {
this.stopDate = stopDate;
}
//setter and getter methods for corresponding columns i.e. properties
}
in Organization Database table, if any row's stop_date column value is less than current date(sysdate) , we should not fetch those rows using Hibernate.
Ex: Org data base table.
ODBID Column1 Column2 stop_date
1 - - 2015-02-13
2 - - 2010-04-23
3 - - 2009-03-13
Here is the SQL statement and Output ,which I am expecting.
SELECT ODBID, , from ORG WHERE stop_date>sysdate ;
ODBID Column1 Column2 stop_date
1 - - 2015-02-13
Like this , I have so many tables, which has stop_date as column, from any one of the table, if the stop_date < sysdate, i don't want to retrieve those records ..
I am not interested to write stop_date>sysdate condition in each SQL/HQL select query. Is there any way I can configure this condition once, and use in all the Entity (POJO ) classes.
Please provide me a generic way.