I'm developing a fitness tracker android app and have set up a SQLite database with 2 tables successfully. One table is for saving data about cardio exercises and one table is for saving data about weight lifting exercises. I'm able to save information to the cardio table (saved_workout_cardio) however, I can't seem to save anything to the weight lifting table (saved_workout_weights). I started off by coding the functionality for saving to 'saved_workout_cardio' table and once I had successfully got that working, I just copy and pasted the code and edited it to fit what was needed for saving to 'saved_workout_weights' table, however unfortunately it's not working and I'm puzzled as to why.
Below is the code from my databasehelper java class where I create the database as well as 2 methods, 1 for saving data to each table:
public class DatabaseHelper extends SQLiteOpenHelper {
public static final String DATABASE_NAME = "FitnessTracker.db";
public static final String TABLE_WEIGHTS = "saved_workout_weights";
public static final String COL_1 = "ID";
public static final String COL_2 = "DATE";
public static final String COL_3 = "EXERCISE";
public static final String COL_4 = "WEIGHT";
public static final String COL_5 = "REPS";
public static final String COL_6 = "SETS";
public static final String TABLE_CARDIO = "saved_workout_cardio";
public static final String COL_1a = "ID";
public static final String COL_2a = "DATE";
public static final String COL_3a = "TIME";
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, 1);
}
#Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("create table " + TABLE_WEIGHTS + " (ID INTEGER PRIMARY KEY AUTOINCREMENT,DATE TEXT,EXERCISE TEXT,WEIGHT INTEGER,REPS INTEGER)");
db.execSQL("create table " + TABLE_CARDIO + " (ID INTEGER PRIMARY KEY AUTOINCREMENT,DATE TEXT,TIME INTEGER)");
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("CREATE TABLE IF NOT EXISTS " + TABLE_WEIGHTS);
db.execSQL("CREATE TABLE IF NOT EXISTS " + TABLE_CARDIO);
onCreate(db);
}
public boolean saveData (String date, String time) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(COL_2a, date);
contentValues.put(COL_3a, time);
long result = db.insert(TABLE_CARDIO, null, contentValues);
if(result == -1)
return false;
else
return true;
}
public boolean saveData2 (String date, String exercise, String weight, String reps, String sets) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues contentValues2 = new ContentValues();
contentValues2.put(COL_2, date);
contentValues2.put(COL_3, exercise);
contentValues2.put(COL_4, weight);
contentValues2.put(COL_5, reps);
contentValues2.put(COL_6, sets);
long result = db.insert(TABLE_WEIGHTS, null, contentValues2);
if(result == -1)
return false;
else
return true;
}
}
Now here's the relevant code from my 'Cardio' java class where I'm calling the method for saving data to the cardio table (this method works and I'm able to save data to the cardio table successfully:
public void saveCardioData () {
btnSaveCardio.setOnClickListener(
new View.OnClickListener() {
#Override
public void onClick(View v) {
boolean isInserted = myDb.saveData(txtDate.getText().toString(),
txtTimer.getText().toString() );
if(isInserted = true)
Toast.makeText(Cardio.this, "Workout saved", Toast.LENGTH_LONG).show();
else
Toast.makeText(Cardio.this, "Error saving workout", Toast.LENGTH_LONG).show();
}
}
);
}
Now here's the 'weights' java class where I call the method for saving data to the weights table. As you can see I have set up a toast message to appear if data is successfully inserted. Whenever I click to save the workout in my app the toast message tells me that the workout has been successfully saved however, when I check the weights table in my database no values have been saved.
public void saveWeightsData () {
btnSaveWeights.setOnClickListener(
new View.OnClickListener() {
#Override
public void onClick(View v) {
boolean isInserted = myDb.saveData2(exerciseVal.getText().toString(),
weightVal.getText().toString(),
repVal.getText().toString(),
setVal.getText().toString(),
dateVal.getText().toString() );
if(isInserted = true)
Toast.makeText(WeightsMain.this, "Workout saved", Toast.LENGTH_LONG).show();
else
Toast.makeText(WeightsMain.this, "Error saving workout", Toast.LENGTH_LONG).show();
}
}
);
}
Really confused as to why I'm having this problem, so if anyone can tell me why it would be greatly appreciated! :)
EDIT: I'm using Android Device Monitor within Android studio to pull the database from the android emulator's storage to my pc. I then use SQLite Manager firefox addon to check the 2 tables.
There's no SETS column in your table but you're trying to insert data to it. That won't work.
After adding the SETS column to the CREATE TABLE, you can uninstall your app to force onCreate() to execute again.
Related
This question already has an answer here:
sqlite get ROWID
(1 answer)
Closed 1 year ago.
I have an android studio app that uses sqlite to save user data such as username, password, etc. In the login page after the user enters his login credentials, the user clicks on a button that calls the following function from a DatabaseHelper java class to check if the info is correct:
public boolean checkLogin(String username, String password){
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.rawQuery("SELECT * FROM user WHERE username=? AND password=? ",
new String[] {username, password});
if (cursor.getCount() > 0){
return true;
}
else {
return false;
}
}
I want to save the row ID that matches this user so I can use it in the future and I was thinking of saving the ID into a variable that I will then send to different activities using an intent. The issue is that I can't figure out how to save the ID from the query.
I'd suggest returning a int rather than boolean the long being the id or -1 if the user/password combination doesn't exist. So :-
public int checkLogin(String username, String password){
int rv = -1;
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.rawQuery("SELECT * FROM user WHERE username=? AND password=? ",
new String[] {username, password});
if (cursor.moveToFirst()) {
rv = cursor.getInt(cursor.getColumnIndex("id"));
}
cursor.close();
return rv;
}
Instead of using something like :-
if (checkLogin("the_user","the_password")) {
logged in code ....
} else {
not logged in code ....
}
You could use something like :-
private int current_userid = -1; // probably declared as a class variable
....
if ((current_userid = db.checkLogin("the_user","the_password")) > 0 ) {
logged in OK code ....
} else {
not logged in code ....
}
I want to save the row ID that matches this user so I can use it in the future and I was thinking of saving the ID into a variable that I will then send to different activities using an intent.
Here's an example that does that and sends the id to another Activity (NextActivity) and then returns (finishes) from that activity after writing the username and password to the log.
First the Database Helper DBHelper :-
class DBHelper extends SQLiteOpenHelper {
SQLiteDatabase db;
public DBHelper(#Nullable Context context) {
super(context, "mydb", null, 1);
db = this.getWritableDatabase();
}
#Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE IF NOT EXISTS user (" +
"id INTEGER PRIMARY KEY, " +
"username TEXT UNIQUE, " +
"password TEXT " +
")");
ContentValues cv = new ContentValues();
cv.put("username","fred");
cv.put("password","password_for_fred");
db.insert("user",null,cv);
}
#Override
public void onUpgrade(SQLiteDatabase db, int i, int i1) { }
public int checkLogin(String username, String password){
int rv = -1;
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.rawQuery("SELECT * FROM user WHERE username=? AND password=? ",
new String[] {username, password});
if (cursor.moveToFirst()) {
rv = cursor.getInt(cursor.getColumnIndex("id"));
}
cursor.close();
return rv;
}
public Cursor getUserById(int userId) {
return db.query("user",null,"id=?",new String[]{String.valueOf(userId)},null,null,null);
}
}
Note that this uses a single class variable for the SQLiteDatabase, so only needs the 1 getWriteableDatabase. It also forces the database to open when constructing by including db = this.getWriteableDatabase(); in the constructor.
Note the added method getUserById(ing userId) method which returns a Cursor according to the userId.
Note that a demo user is added to the table when it is created.
MainActivity (a little overly complex as it demonstrates both a failed login attempt (1st) as well as a successful login attempt (as part of handling the failed attempt)) :-
public class MainActivity extends AppCompatActivity {
public static final String INTENT_EXTRA_CURRENT_USERID = "current_userid";
DBHelper db;
private int current_userid = -1;
private Intent intent;
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
db = new DBHelper(this);
Log.d("LOGIN1","Attempting to Login"); // Will purposefully fail login
if ((current_userid = db.checkLogin("the_user","the_password")) > 0 ) {
Log.d("LOGIN2","Successfully Logged in to user with ID = " + String.valueOf(current_userid));
gotoNextActivity();
} else {
Toast.makeText(this,"Invalid Login, please try again",Toast.LENGTH_SHORT).show();
Log.d("LOGIN1","First attempt to login failed");
// Make 2nd attempt (will work as username and password are correct)
Log.d("LOGIN2","Attemtping to Login (2nd) ");
if((current_userid = db.checkLogin("fred","password_for_fred")) > 0 ) {
Log.d("LOGIN2","Successfully Logged in to user with ID = " + String.valueOf(current_userid));
gotoNextActivity();
}
}
}
private void gotoNextActivity() {
intent = new Intent(this,NextActivity.class);
intent.putExtra(INTENT_EXTRA_CURRENT_USERID,current_userid);
startActivity(intent);
}
}
Finally NextActivity :-
public class NextActivity extends AppCompatActivity {
private int current_userid;
private String current_username, current_password;
private DBHelper db;
Cursor csr;
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_next);
db = new DBHelper(this);
current_userid = this.getIntent().getIntExtra(MainActivity.INTENT_EXTRA_CURRENT_USERID,-1);
csr = db.getUserById(current_userid);
if (csr.moveToFirst()) {
current_username = csr.getString(csr.getColumnIndex("username"));
current_password = csr.getString(csr.getColumnIndex("password"));
}
if (current_userid > 0) {
Log.d("NEXTACTIVTY","Valid user ID - Username = " + current_username + " password is " + current_password);
} else {
Log.d("NEXTACTIVITY","No Valid userid?");
}
// Finish the Activity and hence return to MainActivity
// Hence it is unlikely that the NextActivity will even be noticed.
finish();
}
#Override
protected void onDestroy() {
super.onDestroy();
if (!csr.isClosed()) {
csr.close();
Log.d("NEXTACTIVITY","Closing Cursor in onDestroy method");
}
}
}
Result
When run the log includes :-
2021-07-17 12:19:37.201 D/LOGIN1: Attempting to Login
2021-07-17 12:19:37.211 D/LOGIN1: First attempt to login failed
2021-07-17 12:19:37.211 D/LOGIN2: Attemtping to Login (2nd)
2021-07-17 12:19:37.212 D/LOGIN2: Successfully Logged in to user with ID = 1
2021-07-17 12:19:37.392 D/NEXTACTIVTY: Valid user ID - Username = fred password is password_for_fred
2021-07-17 12:19:37.745 D/NEXTACTIVITY: Closing Cursor in onDestroy method
Basically you just need the
cursor.getInt([column position])
or
cursor.getString([column position])
to retrieve the data from the columns in the database. I made an example I hope this helps you. I'm not very familiar with programming language some cases so I can't argue more.
public class User {
private int id;
private String name;
private String password;
private boolean isLogged = false;
public User() {
}
public void setId(int id) {
this.id = id;
}
public int getId() {
return id;
}
public boolean isLogged() {
return isLogged;
}
public void setLogged(boolean x) {
this.isLogged = x;
}
}
Method to retrieve the Id requested you could just create a String or something..
public User checkLogin(String username, String password) {
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.rawQuery("SELECT * FROM user WHERE username=? AND password=? ", new String[] {username, password});
if (cursor.moveToFirst() || cursor.getCount() > 0) {
User user = new User();
user.setId(cursor.getInt(0));//if you created a primary key should be the first column
user.setLogged(true);
cursor.close();// * Closes the Cursor, releasing all of its resources and making it completely invalid.
db.close(); // * Releases a reference to the object, closing the object if the last reference* was released.
return user;
} else {
return null;
}
}
I want to download data from the Firebase Firestore (array of names) and create the SQL table and feed the table with the data from the server. And every time I launch the app, I check version number from firebase, if it is the same as the SQL database version, and if it's not I recreate the table and populate it with new data.
Problem is I did something wrong with creating and checking the version number, so I get
android.database.sqlite.SQLiteException: Can't downgrade database from version 5 to 4.
This exception is pretty straightforward but I do not know where I messed up.
This is my SQLiteOpenHelper class
public class SQLBazaNamirnica extends SQLiteOpenHelper {
private static final String Ime_Baze = "baza_namirnica";
private static final String IME_TABELE = "tabela_namirnica";
private static final String ID_KOLONA = "id";
private static final String NAMIRNICA_KOLONA = "namirnica";
private static int VERZIJA_BAZE = 4;
SQLiteDatabase db;
Context context;
public SQLBazaNamirnica(Context context) {
super(context, Ime_Baze, null, VERZIJA_BAZE);
}
#Override
public void onCreate(SQLiteDatabase sqLiteDatabase) {
this.db = sqLiteDatabase;
String kreirajTabelu = "CREATE TABLE " + IME_TABELE +
" (" + ID_KOLONA + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
NAMIRNICA_KOLONA + " TEXT )";
db.execSQL(kreirajTabelu);
}
#Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int staraV, int novaV) {
if(staraV != novaV)
sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + IME_TABELE);
}
boolean CheckVerziju(int novaVer) {
//db = getWritableDatabase();
SQLiteDatabase _db = this.getWritableDatabase();
Log.d("SQL VERZIJA", "CheckVerziju: VERZIJA BAZE: " + _db.getVersion() + " \n VERZIJA FIREBASE BAZE: " + novaVer);
if(_db.getVersion() != novaVer) {
//VERZIJA_BAZE = novaVer;
_db.setVersion(novaVer);
return true;
} else return false;
}
void KreirajTabelu() {
SQLiteDatabase db = this.getWritableDatabase();
db.execSQL("DROP TABLE IF EXISTS " + IME_TABELE);
String kreirajTabelu = "CREATE TABLE " + IME_TABELE +
" (" + ID_KOLONA + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
NAMIRNICA_KOLONA + " TEXT )";
db.execSQL(kreirajTabelu);
Log.d("SQL", "KreirajTabelu: BAZA JE KREIRANA");
}
void updateBazu(SQLiteDatabase db, ArrayList<String> namirnice) {
db = getWritableDatabase();
ContentValues cv = new ContentValues();
for(String namirnica : namirnice) {
/* String query = "INSERT INTO " + IME_TABELE + " (" +
NAMIRNICA_KOLONA + ") VALUES (" + namirnica + ")"; */
cv.put(NAMIRNICA_KOLONA, namirnica);
db.insert(IME_TABELE, null, cv);
}
}
}
And this is how I'm the checking version number :
bazaNamirnica = new SQLBazaNamirnica(MainActivity.this);
namirniceDokument.get().addOnSuccessListener(new OnSuccessListener<DocumentSnapshot>() {
#Override
public void onSuccess(DocumentSnapshot documentSnapshot) {
if(documentSnapshot.exists()) {
int verzijaBaze = documentSnapshot.getLong("verzija").intValue();
if(bazaNamirnica.getReadableDatabase().getVersion() != verzijaBaze) {
//bazaNamirnica.ve
bazaNamirnica.KreirajTabelu();
Map<String, Object> namirnice = documentSnapshot.getData();
ArrayList<String> namirniceFinal = new ArrayList<>();
for(Map.Entry<String, Object> namirnica : namirnice.entrySet()) {
namirniceFinal.add(namirnica.getValue().toString());
}
bazaNamirnica.updateBazu(bazaNamirnica.getWritableDatabase(), namirniceFinal);
bazaNamirnica.getWritableDatabase().setVersion(verzijaBaze);
}
First of all, you should always consider checking if you have an updated version which is greater than your current version of the database. The onUpgrade function will only be called when there is an increase in the database version.
I am not sure what are the data that you are getting from the firebase database. However, I would like to suggest some changes to your code.
Instead of checking not equal, you might consider checking if the database version is greater like the following.
if (bazaNamirnica.getReadableDatabase().getVersion() < verzijaBaze) {
// Do the upgrade operation.
}
And also, I am not sure what you are trying to do on the version update. However, if you are dropping a table, you might need to create a new one with the updated structure that you need while upgrading your database.
#Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int staraV, int novaV) {
// if(staraV != novaV) // Not necessary, as this will be called on increase in the database version.
// So you have dropped the table here
sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + IME_TABELE);
// Should create a new one with the updated database schema that you got
createDatabaseTableWithUpdatedSchema();
}
Hope that helps!
At first it was no such table:teacher_table , read posts told me to uninstall which i did and the the table was created but when tried to insert data in it,i got another error
Error inserting teacher_password=123 teacher_lname=soukat teacher_email=a#a.com course_id=1 teacher_mobile=12345432 admin_id=1 teacher_fname=galina teacher_no=tr001 teacher_username=mali
: no such table: main.course_name (code 1): , while compiling: INSERT INTO teacher_table(teacher_password,teacher_lname,teacher_email,course_id,teacher_mobile,admin_id,teacher_fname,teacher_no,teacher_username)VALUES(?,?,?,?,?,?,?,?,?)
Unfortunately i did not write any query to create the above table causing the error.
SitmDatabaseHelper.java
public class SitmDatabaseHelper extends SQLiteOpenHelper {
private static String dbName = "sitm_db.db";
private static int dbVersion =15;
private final static String dg = "databaseTest";
public SitmDatabaseHelper(Context context) {
super(context, dbName, null, dbVersion);
Log.d(dg, "SitmDatabaseHelper: db created");
}
//this method when called returns an instance of the helper class
public static SitmDatabaseHelper getDatabaseHelper(Context context){
SitmDatabaseHelper instance;
instance = new SitmDatabaseHelper(context);
return instance;
}
#Override
public void onCreate(SQLiteDatabase db) {
try{
Log.d(dg, "onCreate: ONCREATE METHOD CALLED");
//creating the admin table
db.execSQL(AdminTable.adminTableQuery);
db.execSQL(StaffTable.staffTableQuery);
db.execSQL(CourseTable.courseTableQuery);
db.execSQL(BatchTable.batchTableQuery);
db.execSQL(TeacherTable.teacherTableQuery);
}catch (Exception e){
Log.d("TableCreation", "onCreate: table creation failed at "+e.getMessage());
}
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
//dropping older table if exists
try{
db.execSQL(AdminTable.dropAdminQuery);
db.execSQL(StaffTable.dropStaffQuery);
db.execSQL(CourseTable.dropCourseQuery);
db.execSQL(BatchTable.dropTableQuery);
db.execSQL(TeacherTable.dropTeacherQuery);
}catch (Exception e){
Log.d("dropTables", "onUpgrade: failed to drop table "+e.getMessage());
}
onCreate(db);
}
#Override //overriden to enable foreign keys
public void onOpen(SQLiteDatabase db) {
db.execSQL("PRAGMA foreign_keys=ON");
}
#Override
public void onConfigure(SQLiteDatabase db) {
db.setForeignKeyConstraintsEnabled(true);
}
}
TeacherTable.java
public final class TeacherTable {
//public static final String TEACHER_TABLE,teacherId,teacherNo,teacherFname,teacherLname,teacherUsername,teacherEmail, teacherPassword,
//
public static final String TEACHER_TABLE="teacher_table",
teacherId="teacher_id",
teacherNo="teacher_no",
teacherFname="teacher_fname",
teacherLname="teacher_lname",
teacherUsername="teacher_username",
teacherEmail="teacher_email",
teacherPassword="teacher_password",
teacherMobile="teacher_mobile",
teacherDate="teacher_date",
adminId="admin_id",
courseId="course_id";
public static final String teacherTableQuery="CREATE TABLE IF NOT EXISTS "+TeacherTable.TEACHER_TABLE+"("
+teacherId+" INTEGER PRIMARY KEY AUTOINCREMENT, "
+teacherNo+" TEXT,"
+teacherFname+" TEXT, "
+teacherLname+" TEXT, "
+teacherUsername+" TEXT,"
+teacherEmail+" TEXT,"
+teacherPassword+" TEXT,"
+teacherMobile+" TEXT,"
+adminId+" INTEGER NOT NULL,"
+courseId+" INTEGER NOT NULL, "
+"FOREIGN KEY("+adminId+")"+" REFERENCES "+AdminTable.adminTable+"("+AdminTable.sId +"),"
+"FOREIGN KEY("+courseId+")"+" REFERENCES "+CourseTable.courseName+"("+CourseTable.courseID+")"
+")";
public final static String dropTeacherQuery = "DROP TABLE IF EXISTS "+ TEACHER_TABLE;
}
>**TeacherDao.java ("add method")**
public class TeacherDao extends DBconnectionHelper {
public TeacherDao(Context tcontext) {
super(tcontext);
}
//add teacher
public void addTeacher(TeacherModal teacherModal){
long status;
//connection
openWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(TeacherTable.adminId , teacherModal.getAdmin().getSuper_admin_id());
contentValues.put(TeacherTable.courseId,teacherModal.getCourse().getCourse_id());
contentValues.put(TeacherTable.teacherNo,teacherModal.getTeacher_no());
contentValues.put(TeacherTable.teacherFname , teacherModal.getTeacher_fname());
contentValues.put(TeacherTable.teacherLname , teacherModal.getTeacher_lname());
contentValues.put(TeacherTable.teacherUsername,teacherModal.getTeacher_username());
contentValues.put(TeacherTable.teacherEmail , teacherModal.getTeacher_email());
contentValues.put(TeacherTable.teacherPassword,teacherModal.getTeacher_password());
contentValues.put(TeacherTable.teacherMobile ,teacherModal.getTeacher_mobile());
try{
database.insert(TeacherTable.TEACHER_TABLE, null , contentValues);
}catch (Exception e){
Log.d("TeacherTable" , "reason "+e.getMessage());
e.printStackTrace();
}
// close connection
closeDatabase();
//return status;
}
AddTeacherFragment.java
public void onCreate(#Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//DAOs
coursesDao = new CoursesDao(getActivity());
teacherDao = new TeacherDao(getActivity());
teacherDao.addTeacher(new TeacherModal("tr001","galina","soukat","mali",
"a#a.com","123","12345432",new SuperAdminModal(1),new CourseModal(1)));
}
Unfortunately i did not write any query to create the above table
causing the error.
Assuming that you really meant to say i did not write any query to use the above table; you did implicitly by defining teacher_table table with :-
+"FOREIGN KEY("+courseId+")"+" REFERENCES "+CourseTable.courseName+"("+CourseTable.courseID+")"
That is to insert into the teacher_table the value in the courseId column must match the specified column (whatever CourseTable.courseID resolves to) in the course_name table (i.e. CourseTable.courseName resolves to course_name).
However, as the table course_name doesn't exist the FOREIGN KEY constraint cannot even be checked. Hence the failure.
You MUST define the course_name table and you must also populate it with appropriate values unless you remove the FOREIGN KEY constraint.
I recently launched an app on the android app store that contained a SQLite database.
I am now attempting to release an update of the app, and want to add more data into the existing database, however have come a bit unstuck. I have read answers on SO that outline making changes to the database itself, however I want my tables and columns to stay the same, only add new data in.
The data that i want to add to the database is pulled from CSV files in the Raw file, and originally loaded into the database when the user registers for the app.
I have a feeling I am going to need to implement the onUpgrade method, however should I be adding the new data from the CSV files in at that point as well? Is it a matter of simple updating the database version and using the onUpgrade to load the new data?
I am fairly new to SQLite DB, so any help would be hugely appreciated.
CourseDBHelper Code
public class CourseDBHelper extends SQLiteOpenHelper {
// Database Version
private static final int DATABASE_VERSION = 1;
// Database Name
private static final String DATABASE_NAME = "CourseDB";
// Create two table names
private static final String TABLE_COURSES = "courses";
// Universities Table Columns names
private static final String COURSE_NAME = "Course_name";
private static final String UNI_NAME = "Uni_name";
private static final String COURSE_DURATION = "Duration";
private static final String COURSE_STUDY_MODE = "Study_mode";
private static final String COURSE_QUALIFICATION = "Qualification";
private static final String COURSE_ENTRY_STANDARDS = "Entry_standards";
private static final String COURSE_GRADUATE_PROSPECTS = "Graduate_prospects";
private static final String COURSE_STUDENT_SATISFACTION = "Student_satisfaction";
private String CREATE_COURSES_TABLE = "CREATE TABLE courses" +
"(" +
"_id INTEGER PRIMARY KEY AUTOINCREMENT," +
"Course_name TEXT NOT NULL," +
"Uni_name TEXT NOT NULL," +
"Duration TEXT NOT NULL," +
"Study_mode TEXT NOT NULL," +
"Qualification TEXT NOT NULL," +
"Entry_standards TEXT NOT NULL," +
"Graduate_prospects TEXT NOT NULL," +
"Student_satisfaction TEXT NOT NULL" +
");";
private static final String[] COLUMNS = {
COURSE_NAME,
UNI_NAME,
COURSE_DURATION,
COURSE_STUDY_MODE,
COURSE_QUALIFICATION,
COURSE_ENTRY_STANDARDS,
COURSE_GRADUATE_PROSPECTS,
COURSE_STUDENT_SATISFACTION
};
public CourseDBHelper(Context context)
{
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
// TODO: REMOVED NOT NULL FROM EVERY COLUMN FOR TEST PURPOSES, WILL NEED TO BE READDED
#Override
public void onCreate(SQLiteDatabase db)
{
db.execSQL(CREATE_COURSES_TABLE);
}
public void deleteAll()
{
SQLiteDatabase db = this.getWritableDatabase();
db.delete("courses", null, null);
db.execSQL("delete from " + "courses");
db.close();
}
// Getting one course by course name and uni name
public Course getCourse(String courseName, String uniName) {
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.query(TABLE_COURSES, COLUMNS, " Course_name = ? AND Uni_name = ?",
new String[]{courseName, uniName},
null,
null,
null,
null);
if (cursor != null)
cursor.moveToFirst();
Course course = new Course();
/*
System.out.println(cursor.getString(0));
System.out.println(cursor.getString(1));
System.out.println(cursor.getString(2));
System.out.println(cursor.getString(3));
System.out.println(cursor.getString(4));
System.out.println(cursor.getString(5));
System.out.println(cursor.getString(6));
*/
course.setCourseName(cursor.getString(0));
course.setUniversity(cursor.getString(1));
course.setCourseDuration(cursor.getString(2));
course.setStudyMode(cursor.getString(3));
course.setQualification(cursor.getString(4));
course.setEntryStandards(cursor.getString(5));
course.setGradProspects(cursor.getString(6));
course.setStudentSatisfaction(cursor.getString(7));
return course;
}
public void addCourse(Course course)
{
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(COURSE_NAME, course.getCourseName());
values.put(UNI_NAME, course.getUniversity());
values.put(COURSE_DURATION, course.getCourseDuration());
values.put(COURSE_STUDY_MODE, course.getStudyMode());
values.put(COURSE_QUALIFICATION, course.getQualification());
values.put(COURSE_ENTRY_STANDARDS, course.getEntryStandards());
values.put(COURSE_GRADUATE_PROSPECTS, course.getGradProspects());
values.put(COURSE_STUDENT_SATISFACTION, course.getStudentSatisfaction());
db.insert(TABLE_COURSES,
null, //nullColumnHack
values);
db.close();
}
public ArrayList<Course> getAllCourses()
{
ArrayList<Course> courses = new ArrayList<>();
// 1. build the query
String query = "SELECT * FROM " + TABLE_COURSES;
// 2. get reference to writable DB
SQLiteDatabase db = this.getWritableDatabase();
Cursor cursor = db.rawQuery(query, null);
// 3. go over each row, build course and add it to list
Course course;
if(cursor.moveToFirst()){
cursor.moveToNext();
do{
course = new Course();
course.setCourseName(cursor.getString(1));
course.setUniversity(cursor.getString(2));
course.setCourseDuration(cursor.getString(3));
course.setStudyMode(cursor.getString(4));
course.setQualification(cursor.getString(5));
course.setEntryStandards(cursor.getString(6));
course.setGradProspects(cursor.getString(7));
course.setStudentSatisfaction(cursor.getString(8));
// Add course to courses list
courses.add(course);
} while(cursor.moveToNext());
}
// return courses
return courses;
}
public int getDBCount()
{
SQLiteDatabase db = this.getWritableDatabase();
String count = "SELECT count(*) FROM courses";
Cursor mcursor = db.rawQuery(count, null);
mcursor.moveToFirst();
int icount = mcursor.getInt(0);
return icount;
}
public void deleteCourse(Course course) {
// 1. get reference to writable DB
SQLiteDatabase db = this.getWritableDatabase();
// 2. delete
db.delete("courses", //table name
"Course_name = ? AND Uni_name = ?", // selections
new String[] { course.getCourseName(), course.getUniversity() }); //selections args
// 3. close
db.close();
}
#Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1) {
}
}
Method that loads data from CSV file to SQlite DB
public void populateCourseDatabase(int id) {
// NOW POPULATE THE COURSE DATABASE FILE
inputStream = getResources().openRawResource(R.raw.coursesone);
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
String word;
String cvsSplitBy = ",";
try{
while((word = reader.readLine()) != null){
Log.d(TAG, "constructing Course object from: " + word);
String[] segment = word.split(cvsSplitBy);
Course course = new Course();
course.setCourseName(segment[0]);
course.setUniversity(segment[1]);
course.setCourseDuration(segment[2]);
course.setStudyMode(segment[3]);
course.setQualification(segment[4]);
course.setEntryStandards(segment[5]);
course.setGradProspects(segment[6]);
course.setStudentSatisfaction(segment[7]);
myCourseDBHelper.addCourse(course);
progressBar.setProgress(count);
count = count + 1;
System.out.println("Sucessfully added: " + course.toString());
}
}
catch(IOException e1){
e1.printStackTrace();
System.out.println("SOMETHING WENT WRONG");
}
}
SQLiteOpenHelper onCreate() and onUpgrade() callbacks are invoked when the database is actually opened, for example by a call to getWritableDatabase().onCreate() is only run when the database file did not exist and was just created. onUpgrade() is only called when the database file exists but the stored version number is lower than requested in constructor.Increment the database version so that onUpgrade() is invoked.
Example pseudo code below
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
switch(oldVersion) {
case 1:
//upgrade logic from version 1 to 2
case 2:
//upgrade logic from version 2 to 3
case 3:
//upgrade logic from version 3 to 4
break;
default:
throw new IllegalStateException(
"onUpgrade() with unknown oldVersion " + oldVersion);
}
}
This is my Database class
public class ProgramDbAdapter{
public static final String KEY_ROWID = "_id";
public static final String KEY_PROGRAM_TITLE = "ProgramTitle";
public static final String KEY_PROGRAM_DATE = "ProgramDate";
public static final String KEY_PROGRAM_TIME = "ProgramTime";
public static final String KEY_PROGRAM_CHANNEL = "ProgramChannel";
private static final String DATABASE_CREATE =
"CREATE TABLE " + DATABASE_TABLE + " (" + "_id integer primary key autoincrement, "
+ "ProgramTitle text, " + "ProgramDate varchar(20), "
+ "ProgramTime varchar(20), " + "ProgramChannel text)";
private static final String DATABASE_UPGRADE = "DROP TABLE IF EXISTS " + DATABASE_TABLE;
private static class DatabaseHelper extends SQLiteOpenHelper {
DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
#Override
public void onCreate(SQLiteDatabase db){
db.execSQL(DATABASE_CREATE);
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
+ newVersion + ", which will destroy all old data");
db.execSQL(DATABASE_UPGRADE);
onCreate(db);
}
}
public ProgramDbAdapter open() throws SQLException{
mDbHelper = new DatabaseHelper(mcontext);
mDb = mDbHelper.getWritableDatabase();
return this;
}
public long CreateData(String ProgramTitle, String ProgramDate, String ProgramTime, String ProgramChannel){
ContentValues initialvalues = new ContentValues();
initialvalues.put(KEY_PROGRAM_TITLE, ProgramTitle);
initialvalues.put(KEY_PROGRAM_DATE, ProgramDate);
initialvalues.put(KEY_PROGRAM_TIME, ProgramTime);
initialvalues.put(KEY_PROGRAM_CHANNEL, ProgramChannel);
return mDb.insert(DATABASE_TABLE, null, initialvalues);
}
}
This is my main class
public class Program extends ExpandableListActivity{
public void onCreate(Bundle savedInstanceState) {
mDbHelper = new ProgramDbAdapter(this);
mDbHelper.open();
mDbHelper.CreateData("a","a","a","a");
}
}
when i call open() and createdata function, the logcat tell me no such table:Program. where is the problem is?
There is no varchar type in sqlite, see here. Use text instead.
I don't see where 'DATABASE_TABLE' is coming from.
Also, you should use the "rawQuery()", "query()"-Methods or a "SQLiteStatement" to bind parameters into your SQL-Statement.
And last but not least, SQLite doesn't know any 'varchar'. Check here for all Data types: Link
varchar is translated to text ...
from vladimir link:
If the declared type of the column
contains any of the strings "CHAR",
"CLOB", or "TEXT" then that column has
TEXT affinity. Notice that the type
VARCHAR contains the string "CHAR" and
is thus assigned TEXT affinity.
problem is that u created db in first run and there was different Create statment ...
delete app data from android settings or change DATABASE_VERSION