Android sqlite comment vérifier si un enregistrement existe
Je voudrais vérifier si un disque existe ou non.
Voici ce que j'ai essayé:
MainActivity.class
public void onTextChanged(CharSequence s, int start, int before, int count) {
System.out.println("Ontext changed " + new String(s.toString()));
strDocumentFrom = s.toString();
if(s.toString().isEmpty()){
} else {
try{
strTransactionDate = dbHelper.getTransactionDateByDocumentNumber(strDocumentFrom);
//strTotalAmount = dbHelper.getTotalAmountByDocumentNumber(strDocumentFrom);
//strVan = dbHelper.getVanByDocumentNumber(strDocumentFrom);
//etTransactionDate.setText(strTransactionDate);
//etTotalAmount.setText(strTotalAmount);
//Log.d("Van", "" + strVan);
//etVan.setText(strVan);
} catch (SQLiteException e) {
e.printStackTrace();
Toast.makeText(ReceivingStocksHeader.this,
"Document number does not exist.", Toast.LENGTH_SHORT).show();
}
}
DBHelper.class
// TODO DISPLAYING RECORDS TO TRANSRCVHEADER
public String getTransactionDateByDocumentNumber(String strDocumentNumber){
String[] columns = new String[]{KEY_TRANSACTIONDATE};
Cursor c = myDataBase.query(TBL_INTRANS,
columns, null,
null, null, null, null, null);
if(c != null){
c.moveToFirst();
String date = c.getString(0);
return date;
} else {
Log.d("Error", "No record exists");
}
return null;
}
Mais il ne parvient pas à attraper le pain grillé.
Qu'est-ce que je fais mal ici?
public static boolean CheckIsDataAlreadyInDBorNot(String TableName,
String dbfield, String fieldValue) {
SQLiteDatabase sqldb = EGLifeStyleApplication.sqLiteDatabase;
String Query = "Select * from " + TableName + " where " + dbfield + " = " + fieldValue;
Cursor cursor = sqldb.rawQuery(Query, null);
if(cursor.getCount() <= 0){
cursor.close();
return false;
}
cursor.close();
return true;
}
J'espère que cela vous sera utile .... Cette fonction renvoie true si l'enregistrement existe déjà dans la base de données. Sinon, renvoie false.
Ce sont toutes de bonnes réponses, mais beaucoup oublient de fermer le curseur et la base de données. Si vous ne fermez pas le curseur ou la base de données, vous risquez d'avoir des fuites de mémoire.
Aditionellement:
Lors de la recherche avec String, vous pouvez obtenir une erreur contenant des caractères non alphanumériques. Par exemple: "1a5f9ea3-ec4b-406b-a567-e6927640db40". Ces tirets (-) provoqueront une erreur unrecognized token. Vous pouvez résoudre ce problème en plaçant la chaîne dans un tableau. Donc, prenez l'habitude d'interroger comme ceci:
public boolean hasObject(String id) {
SQLiteDatabase db = getWritableDatabase();
String selectString = "SELECT * FROM " + _TABLE + " WHERE " + _ID + " =?";
// Add the String you are searching by here.
// Put it in an array to avoid an unrecognized token error
Cursor cursor = db.rawQuery(selectString, new String[] {id});
boolean hasObject = false;
if(cursor.moveToFirst()){
hasObject = true;
//region if you had multiple records to check for, use this region.
int count = 0;
while(cursor.moveToNext()){
count++;
}
//here, count is records found
Log.d(TAG, String.format("%d records found", count));
//endregion
}
cursor.close(); // Dont forget to close your cursor
db.close(); //AND your Database!
return hasObject;
}
vous pouvez aussi voir ceci:
if (cursor.moveToFirst()) {
// record exists
} else {
// record not found
}
OR
Vous venez de cocher Cursor not null après cela, pourquoi vous activez le nombre et non 0.
Alors, que vous essayez ceci ...
DBHelper.getReadableDatabase();
Cursor mCursor = db.rawQuery("SELECT * FROM " + DATABASE_TABLE + " WHERE yourKey=? AND yourKey1=?", new String[]{keyValue,keyvalue1});
if (mCursor != null)
{
return true;
/* record exist */
}
else
{
return false;
/* record not exist */
}
Les requêtes brutes sont plus vulnérables à l'injection SQL. Je vais suggérer d'utiliser la méthode query() à la place.
public boolean Exists(String searchItem) {
String[] columns = { COLUMN_NAME };
String selection = COLUMN_NAME + " =?";
String[] selectionArgs = { searchItem };
String limit = "1";
Cursor cursor = db.query(TABLE_NAME, columns, selection, selectionArgs, null, null, null, limit);
boolean exists = (cursor.getCount() > 0);
cursor.close();
return exists;
}
Source: ici
Vous pouvez utiliser la commande SELECT EXISTS et l'exécuter pour une cursor en utilisant une rawQuery, De la documentation.
L'opérateur EXISTS évalue toujours l'une des valeurs entières 0 et 1. Si vous exécutez l'instruction SELECT spécifiée comme étant la main droite l'opérande de l'opérateur EXISTS renverrait une ou plusieurs lignes, puis le L’opérateur EXISTS évalue à 1. Si exécuter, SELECT renverrait pas de lignes du tout, l'opérateur EXISTS est évalué à 0.
J'ai essayé toutes les méthodes mentionnées dans cette page, mais seule la méthode ci-dessous a bien fonctionné pour moi.
Cursor c=db.rawQuery("SELECT * FROM user WHERE idno='"+txtID.getText()+"'", null);
if(c.moveToFirst())
{
showMessage("Error", "Record exist");
}
else
{
// Inserting record
}
Code:
private String[] allPushColumns = { MySQLiteHelper.COLUMN_Push_ID,
MySQLiteHelper.COLUMN_Push_TITLE, MySQLiteHelper.COLUMN_Push_CONTENT, MySQLiteHelper.COLUMN_Push_TIME,
MySQLiteHelper.COLUMN_Push_TYPE, MySQLiteHelper.COLUMN_Push_MSG_ID};
public boolean checkUniqueId(String msg_id){
Cursor cursor = database.query(MySQLiteHelper.TABLE_Push,
allPushColumns, MySQLiteHelper.COLUMN_Push_MSG_ID + "=?", new String [] { msg_id }, null, null, MySQLiteHelper.COLUMN_Push_ID +" DESC");
if(cursor.getCount() <= 0){
return false;
}
return true;
}
SELECT EXISTS with LIMIT 1 est beaucoup plus rapide.
Query Ex: SELECT EXISTS (SELECT * FROM table_name WHERE column='value' LIMIT 1);
Code Ex:
public boolean columnExists(String value) {
String sql = "SELECT EXISTS (SELECT * FROM table_name WHERE column='"+value+"' LIMIT 1)";
Cursor cursor = database.rawQuery(sql, null);
cursor.moveToFirst();
// cursor.getInt(0) is 1 if column with value exists
if (cursor.getInt(0) == 1) {
cursor.close();
return true;
} else {
cursor.close();
return false;
}
}
SQLiteDatabase sqldb = MyProvider.db;
String Query = "Select * from " + TABLE_NAME ;
Cursor cursor = sqldb.rawQuery(Query, null);
cursor.moveToLast(); //if you not place this cursor.getCount() always give same integer (1) or current position of cursor.
if(cursor.getCount()<=0){
Log.v("tag","if 1 "+cursor.getCount());
return false;
}
Log.v("tag","2 else "+cursor.getCount());
return true;
si vous n'utilisez pas cursor.moveToLast();
cursor.getCount() donne toujours le même entier (1) ou la position actuelle du curseur.
Vous pouvez utiliser comme ceci:
String Query = "Select * from " + TABLE_NAME + " where " + Cust_id + " = " + cust_no;
Cursor cursorr = db.rawQuery(Query, null);
if(cursor.getCount() <= 0){
cursorr.close();
}
cursor.close();
Voici une solution simple basée sur une combinaison de ce que dipali et Piyush Gupta ont publié:
public boolean dbHasData(String searchTable, String searchColumn, String searchKey) {
String query = "Select * from " + searchTable + " where " + searchColumn + " = ?";
return getReadableDatabase().rawQuery(query, new String[]{searchKey}).moveToFirst();
}
en raison de possibles fuites de données, meilleure solution via le curseur:
Cursor cursor = null;
try {
cursor = .... some query (raw or not your choice)
return cursor.moveToNext();
} finally {
if (cursor != null) {
cursor.close();
}
}
1) À partir de l'API KitKat, vous pouvez utiliser les ressources try ()
try (cursor = ...some query)
2) Si vous interrogez VARCHAR TYPE, utilisez '...' eg. COLUMN_NAME = 'string_to_search'
3) ne pas utiliser moveToFirst () est utilisé lorsque vous devez commencer à itérer depuis le début
4) Eviter que getCount () coûte cher - il parcourt de nombreux enregistrements pour les compter. Il ne retourne pas une variable stockée. Il peut y avoir une mise en cache sur un deuxième appel, mais le premier appel ne connaît pas la réponse tant qu’elle n’a pas été comptée.
Essayez d'utiliser la méthode cursor.isNull . Exemple:
song.isFavorite = cursor.isNull(cursor.getColumnIndex("favorite"));