We Keep Coding

How to get data from server and populate SQL database on Android?

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!

How to update an existing SQLite db table data with new android app update?

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);
}
}

can I add android sqlite transaction in other class(not MyDatabaseHelper, not MyDB)?

As I make the SQLite in android app, I made 3 class.
first is "MyDatabaseHelper.java" that make database and table.
second is "MyDB.java" that contain some functions(insert, cursor, update, delete).
third is "MyDBDefaultValues" that make default values using insert function in "MyDB.java".
The point is about transaction.
following the transaction manual(Android Database Transaction),
I need to insert "db.beginTransaction()" into "MyDB.java" because there are SQLitebase.
but I make the default values using insert function in other class(MyDBDefaultValues.java).
As a results, I don't know where to add transaction in my code. I know if I make a default code in "MyDB.java", I can add transaction in "MyDB.java".
but I want to separate "MyDB.java" and "MyDBDefaultValues.java".please tell me how to add transaction in my code.
Under is my code.
MyDatabaseHelper.java
public class MyDatabaseHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "Torticollis";
private static final int DATABASE_VERSION = 1;
// Database creation sql statement
private static final String DATABASE_CREATE = "create table Torticollis_Management(" +
"_id integer primary key autoincrement, " +
"date text not null, " + // store date to text type and convert between formats using the built-in date and time functions
"stretching1 text, " +
"stretching2 text, " +
"stretching3 text, " +
"stretching4 text, " +
"stretching5 text," +
"today_pain integer);";
public MyDatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
Log.d("confirm", "this is first's god");
}
// Method is called during creation of the database
#Override
public void onCreate(SQLiteDatabase database) {
database.execSQL(DATABASE_CREATE);
}
// Method is called during an upgrade of the database,
#Override
public void onUpgrade(SQLiteDatabase database,int oldVersion,int newVersion){
Log.w(MyDatabaseHelper.class.getName(),
"Upgrading database from version " + oldVersion + " to "
+ newVersion + ", which will destroy all old data");
database.execSQL("DROP TABLE IF EXISTS Torticollis_Management");
onCreate(database);
}
}
MyDB.java
public class MyDB{
private MyDatabaseHelper dbHelper;
private SQLiteDatabase database;
public final static String Tor_TABLE = "Torticollis_Management"; // name of table
public final static String Tor_ID = "_id"; // id value for Torticollis
public final static String Tor_DATE = "date"; // date of Torticollis
public final static String Tor_STRETCHING1 = "stretching1"; // stretching1 of Torticollis
public final static String Tor_STRETCHING2 = "stretching2"; // stretching2 of Torticollis
public final static String Tor_STRETCHING3 = "stretching3"; // stretching3 of Torticollis
public final static String Tor_STRETCHING4 = "stretching4"; // stretching4 of Torticollis
public final static String Tor_STRETCHING5 = "stretching5"; // stretching5 of Torticollis
public final static String Tor_TODAY_PAIN = "today_pain"; // today_pain of Torticollis
// today_pain value's type is "String" but it's real type is "int"
/**
*
* #param context
*/
public MyDB(Context context){ // why do I add this 'context'??
dbHelper = new MyDatabaseHelper(context);
}
public long insert(String date, String stretching1, String stretching2, String stretching3,
String stretching4, String stretching5, int today_pain){
database = dbHelper.getWritableDatabase();
ContentValues values = new ContentValues();
// values.put(Tor_ID, id); // "id" don't need to insert because that's made "autoincrement".
values.put(Tor_DATE, date);
values.put(Tor_STRETCHING1, stretching1);
values.put(Tor_STRETCHING2, stretching2);
values.put(Tor_STRETCHING3, stretching3);
values.put(Tor_STRETCHING4, stretching4);
values.put(Tor_STRETCHING5, stretching5);
values.put(Tor_TODAY_PAIN, today_pain); // why do I have to inert "integer"'s today_pain value into "String"'s Tor_TODAY_PAIN?
return database.insert(Tor_TABLE, null, values);
}
public Cursor cursor() {
database = dbHelper.getReadableDatabase();
String[] cols = new String[] {Tor_ID, Tor_DATE, Tor_STRETCHING1, Tor_STRETCHING2, Tor_STRETCHING3,
Tor_STRETCHING4, Tor_STRETCHING5, Tor_TODAY_PAIN};
Cursor mCursor = database.query(true, Tor_TABLE, cols, null, null, null, null, null, null);
if (mCursor != null) {mCursor.moveToFirst();}
return mCursor; // iterate to get each value.
}
public boolean update(String date, String stretching1, String stretching2, String stretching3,
String stretching4, String stretching5, int today_pain) {
database = dbHelper.getWritableDatabase();
ContentValues values = new ContentValues();
// values.put(Tor_ID, id); // "id" don't need to insert because that exist only for counting
values.put("date", date);
values.put("stretching1", stretching1);
values.put("stretching2", stretching2);
values.put("stretching3", stretching3);
values.put("stretching4", stretching4);
values.put("stretching5", stretching5);
values.put("today_pain", today_pain);
database.update("Torticollis_Management", values, "date = ?", new String[]{date}); // need to know this coding
return true;
}
public Integer delete(String date) {
database = dbHelper.getWritableDatabase();
return database.delete("Torticollis_Management", "id = ?", new String[]{date}); // need to know this coding
}
}
MyDBDefaultValues.java
public class MyDBDefaultValues {
MyDB mydb;
public MyDBDefaultValues(Context context){ // why do I have to write the word "context". what's the mean of "context"?
mydb = new MyDB(context);
insertDefaultValues(); // insert default values if there is no data.
}
public void insertDefaultValues() {
Cursor cursor = mydb.cursor();
cursor.moveToLast();
int count = cursor.getCount();
if(count > 0) {
// do nothing
} else { // insert default values if there is no data.
mydb.insert("2016-07-01", "X", "X", "X", "X", "X", 0);
mydb.insert("2016-07-02", "X", "X", "X", "X", "X", 0);
mydb.insert("2016-07-03", "X", "X", "X", "X", "X", 0);
mydb.insert("2016-07-04", "X", "X", "X", "X", "X", 0);
}
}
}

In general, you should put transactions into the outermost function(s); this is both correct (multiple DB operations are then atomic), and more efficient:
public void insertDefaultValues() {
mydb.beginTransaction();
try {
if (mydb.cursor().getCount() == 0) {
mydb.insert(...);
...
}
mydb.setTransactionSuccessful();
} finally {
mydb.endTransaction();
}
}
This requires that you add wrappers for the beginTransaction() etc. calls to your MyDB class.

Unable to start activity in device

I'm trying to follow this tutorial, but I'm getting this error message, when I run on my device:
08-04 01:40:12.820 27896-27896/com.filipeferminiano.quiz E/AndroidRuntime﹕ FATAL EXCEPTION: main
java.lang.RuntimeException: Unable to start activity ComponentInfo{com.filipeferminiano.quiz/com.filipeferminiano.quiz.MyActivity}: java.lang.IllegalStateException: attempt to re-open an already-closed object: SQLiteDatabase: /data/data/com.filipeferminiano.quiz/databases/triviaQuiz
How can I solve this?

Try to replace this class,hope this will help you to solve your problem.
public class DbHelper extends SQLiteOpenHelper {
private static final int DATABASE_VERSION = 1;
// Database Name
private static final String DATABASE_NAME = "triviaQuiz";
// tasks table name
private static final String TABLE_QUEST = "quest";
// tasks Table Columns names
private static final String KEY_ID = "id";
private static final String KEY_QUES = "question";
private static final String KEY_ANSWER = "answer"; //correct option
private static final String KEY_OPTA= "opta"; //option a
private static final String KEY_OPTB= "optb"; //option b
private static final String KEY_OPTC= "optc"; //option c
private SQLiteDatabase dbase;
public DbHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
#Override
public void onCreate(SQLiteDatabase db) {
String sql = "CREATE TABLE IF NOT EXISTS " + TABLE_QUEST + " ( "
+ KEY_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + KEY_QUES
+ " TEXT, " + KEY_ANSWER+ " TEXT, "+KEY_OPTA +" TEXT, "
+KEY_OPTB +" TEXT, "+KEY_OPTC+" TEXT)";
db.execSQL(sql);
addQuestions(db);
}
private void addQuestions(SQLiteDatabase db)
{
Question q1=new Question("Which company is the largest manufacturer" +
" of network equipment?","HP", "IBM", "CISCO", "C");
this.addQuestion(q1,db);
Question q2=new Question("Which of the following is NOT " +
"an operating system?", "SuSe", "BIOS", "DOS", "B");
this.addQuestion(q2,db);
Question q3=new Question("Which of the following is the fastest" +
" writable memory?","RAM", "FLASH","Register","C");
this.addQuestion(q3,db);
Question q4=new Question("Which of the following device" +
" regulates internet traffic?", "Router", "Bridge", "Hub","A");
this.addQuestion(q4,db);
Question q5=new Question("Which of the following is NOT an" +
" interpreted language?","Ruby","Python","BASIC","C");
this.addQuestion(q5,db);
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldV, int newV) {
// Drop older table if existed
db.execSQL("DROP TABLE IF EXISTS " + TABLE_QUEST);
// Create tables again
onCreate(db);
}
// Adding new question
public void addQuestion(Question quest,SQLiteDatabase db) {
ContentValues values = new ContentValues();
values.put(KEY_QUES, quest.getQUESTION());
values.put(KEY_ANSWER, quest.getANSWER());
values.put(KEY_OPTA, quest.getOPTA());
values.put(KEY_OPTB, quest.getOPTB());
values.put(KEY_OPTC, quest.getOPTC());
// Inserting Row
db.insert(TABLE_QUEST, null, values);
}
public List<Question> getAllQuestions() {
List<Question> quesList = new ArrayList<Question>();
// Select All Query
String selectQuery = "SELECT * FROM " + TABLE_QUEST;
dbase=this.getReadableDatabase();
Cursor cursor = dbase.rawQuery(selectQuery, null);
// looping through all rows and adding to list
if (cursor.moveToFirst()) {
do {
Question quest = new Question();
quest.setID(cursor.getInt(0));
quest.setQUESTION(cursor.getString(1));
quest.setANSWER(cursor.getString(2));
quest.setOPTA(cursor.getString(3));
quest.setOPTB(cursor.getString(4));
quest.setOPTC(cursor.getString(5));
quesList.add(quest);
} while (cursor.moveToNext());
}
// return quest list
dbase.close();
return quesList;
}
public int rowcount()
{
int row=0;
String selectQuery = "SELECT * FROM " + TABLE_QUEST;
SQLiteDatabase db = this.getWritableDatabase();
Cursor cursor = db.rawQuery(selectQuery, null);
row=cursor.getCount();
return row;
}
}

the trace already told u the reason why it crashed:
attempt to re-open an already-closed object: SQLiteDatabase

check your database objects it closed some where in your code also check in tutorial there are not anywhere write db.close() so do not close your data base in your example..
thats it...

SQLite (1) no such table

When I run my android app I keep getting the error (1) no such table userTable, as far as I am aware I am creating the table in
TABLE_CREATE = "create table userTable("
+ USER + " text not null, " + PWD + " text not null, );";
I have two other databases in this project and the are working fine, any help is welcome.
package com.weightpro.db;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
public class usrPwdDB {
public static final String USER = "userName";
public static final String PWD = "password";
public static final String TABLE_NAME = "userTable";
public static final String DATA_BASE_NAME = "userdatabase";
public static final String KEY_ROWID = "_id";
public static final int DB_VERSION = 2;
private static final String TABLE_CREATE = "create table userTable("
+ USER + " text not null, " + PWD + " text not null, );";
DBHelper WDBHelper;
Context mContext;
SQLiteDatabase db;
public usrPwdDB(Context mContext) {
this.mContext = mContext;
WDBHelper = new DBHelper(mContext);
}
private static class DBHelper extends SQLiteOpenHelper
{
public DBHelper(Context context) {
super(context,DATA_BASE_NAME, null, DB_VERSION);
}
#Override
public void onCreate(SQLiteDatabase db) {
try{
db.execSQL(TABLE_CREATE);
}
catch(SQLException e)
{
e.printStackTrace();
}
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS userTable");
onCreate(db);
}
}
public usrPwdDB open()
{
db = WDBHelper.getWritableDatabase();
return this;
}
public void close(){
WDBHelper.close();
}
public long insertInfo(String userName, String password){
ContentValues content = new ContentValues();
content.put(USER, userName);
content.put(PWD, password);
return db.insertOrThrow(TABLE_NAME, null, content);
}
public boolean getUserNameAndPassword(String userName, String Password) throws SQLException {
Cursor mCursor =
db.query(true, TABLE_NAME, new String[] {USER,
PWD},USER+"='"+userName+"' AND password='"+Password+"'", null,
null, null, null, null);
if (mCursor.getCount() > 0)
{
return true;
}
return false;}
public Cursor returnData(){
return db.query(TABLE_NAME, new String[] {USER, PWD},null,null,null,null,null);
}
}

remove the last comma , from the create table syntax,
private static final String TABLE_CREATE =
"create table userTable("
+ USER + " text not null, "
+ PWD + " text not null, );"; // remove this comma after not null
The correct syntax should be
private static final String TABLE_CREATE =
"create table userTable("
+ USER + " text not null, "
+ PWD + " text not null );";

You go wrong over here
+ USER + " text not null, " + PWD + " text not null, );"; //remove , from last text not null
correct SQL command with below
private static final String TABLE_CREATE = "create table userTable("
+ USER + " text not null, " + PWD + " text not null);" ;

private static final String TABLE_CREATE = "create table userTable("
+ USER + " text not null, " + PWD + " text not null,);" ;
remove "," after "text not null" and also remove ";"(semicolon) in the string, that is not needed i think,
then clear data or uninstall application then execute again
even though the creation of table failed i think next time onCreate() in SQLiteOpenHelper only executes once, so you will need to clear data of application
if you are using separate class for separate table and using same DB name, then all the tables in the first using class will be ok, and others will not be created since for a single database onCreate() function works only one, even if there is separate classes each with onCreate(),
onCreate() function creates a file in DB location of android file system when first called onCreate(), if the onCreate called again it check for the existence of DBNAME file in DB location and avoid creating if its exit, I think this is logic behind it...
so keep one onCreate() function for a single DB file and create all tables in that function