Android SQLite: अपडेट स्टेटमेंट

Question

मुझे अपने आवेदन में SQLite लागू करने की आवश्यकता है। मैंने इस ट्यूटोरियल का अनुसरण किया .. Android में डेटाबेस बनाना और उसका उपयोग करना

सब कुछ ठीक चल रहा है। मैंने 5 कॉलम के साथ 1 पंक्ति डाली। अब मैं केवल 1 कॉलम का मान अपडेट करना चाहता हूं और अन्य समान रहेंगे।

ट्यूटोरियल में एक अपडेट विधि है, लेकिन इसके लिए सभी मापदंडों की जरूरत है, हालांकि मैं केवल एक कॉलम को अपडेट करना चाहता हूं।

Comments

इस सर्वर पर अनुरोधित URL /index.php/articlesdatastorage/235-creating-and-use-dat डेटाबेस-in-android-one नहीं मिला।

— मचादो

Answer 1

आप नीचे दिए गए कोड का उपयोग कर सकते हैं।

String strFilter = "_id=" + Id;
ContentValues args = new ContentValues();
args.put(KEY_TITLE, title);
myDB.update("titles", args, strFilter, null);

Comments

आप भी कर सकते हैं: myDB.update ("शीर्षक", args, strFilter, नई स्ट्रिंग [] {Integer.toString (ID)}); यदि आपके पास "_id =?" पर स्ट्रैफ़िल्टर सेट है ... तो एक आइटम के साथ कष्टप्रद बात यह है कि आपको अभी भी इसे एक सरणी में रखना होगा, जो इसे असुविधाजनक बना सकता है। फिर भी, सही जवाब के लिए मतदान किया।

— joshhendo

@ धीरज - यह केवल उस कॉलम को अपडेट करेगा जो

— ContentValues

अगर मैं गलत नहीं हूं, तो @joshhendo के कोड को SQL इंजेक्शन को भी रोकना चाहिए, कुछ इस जवाब पर विचार नहीं करता है। चूंकि तर्क को एक पैरामीटर के रूप में पारित किया जाता है, इसलिए यह अंतर्निहित कोड से बच जाता है।

— r41n

आपको अपने चारों ओर उद्धरण लगाने की आवश्यकता होगी Id। कुछ इस तरह:String strFilter = "_id='" + Id + "'";

— गुइलुमे

Answer 2

तुम कोशिश कर सकते हो:

db.execSQL("UPDATE DB_TABLE SET YOUR_COLUMN='newValue' WHERE id=6 ");

या

ContentValues newValues = new ContentValues();
newValues.put("YOUR_COLUMN", "newValue");

db.update("YOUR_TABLE", newValues, "id=6", null);

या

ContentValues newValues = new ContentValues();
newValues.put("YOUR_COLUMN", "newValue");

String[] args = new String[]{"user1", "user2"};
db.update("YOUR_TABLE", newValues, "name=? OR name=?", args);

Answer 3

यह सब ट्यूटोरियल में है कि कैसे करें:

    ContentValues args = new ContentValues();
    args.put(columnName, newValue);
    db.update(DATABASE_TABLE, args, KEY_ROWID + "=" + rowId, null);

ContentValuesअपडेट किए गए कॉलम और उस update()विधि से सेट करने के लिए उपयोग करें जिसमें आपको निर्दिष्ट करना है, तालिका और मापदंड केवल उन पंक्तियों को अपडेट करने के लिए जिन्हें आप अपडेट करना चाहते हैं।

Comments

-1। सवाल एक पंक्ति में एक एकल कॉलम को अपडेट करने का है, न कि पूरी पंक्ति को अपडेट करने का। अलेक्स का जवाब सही है।

— धीरज वेपकोमा

धीरज, आप बस जितने चाहें उतने args.put (columnName, newValue) जोड़ सकते हैं।

— साइमन रॉलिन

Answer 4

आप हमेशा SQL निष्पादित कर सकते हैं।

update [your table] set [your column]=value

उदाहरण के लिए

update Foo set Bar=125

Comments

एक स्पष्ट एसक्यूएल स्टेटमेंट का उपयोग क्यों किया जाता है, अगर उसके लिए एक (बहुत आसान और सुविधाजनक) एपीआई है?

— Stephan

@ स्टेफ़न: क्योंकि इसका मानक SQLite नहीं है। जब डीबी विभिन्न प्लेटफार्मों पर ऐप्स के बीच साझा किया जाता है, तो एपीआई बहुत विशेष रूप से

— जुड़ा हुआ है

@ स्टेफ़न यह प्रश्न का एकमात्र सही उत्तर है। ओपी एक पंक्ति में एक कॉलम को अपडेट करना चाहता है, न कि पूरी पंक्ति को अपडेट करने के लिए।

— धीरज वेपकोमा

एपीआई का उपयोग करना यहां एक बेहतर शर्त है, मुझे आश्चर्य है कि कोई मध्य समाधान नहीं है, सी लाइब्रेरी आपको फॉर्मेटर्स और टोकन को निष्पादित करने और सेट करने के लिए एक एसक्यूएल को परिभाषित करने देता है, अगला चरण चर को बांधने के लिए सी एपीआई का उपयोग कर रहा है। SQL स्ट्रिंग में टोकन, इस प्रकार पार्सिंग त्रुटियों से बचने और समस्याओं का समाधान आदि ... यहाँ यह लगभग बहुत सहायक है, यहां तक ​​कि एसक्यूएल का हिस्सा भी नहीं लिख रहा है, अच्छा नहीं लगता है ... बल्कि यह तब एक कॉनकैटेड एसक्यूएल स्ट्रिंग है।

— डैनियल

यह विधि तब विफल होगी जब स्ट्रिंग में एकल उद्धरण और कुछ विशेष वर्ण होंगे। @ कोई जवाब सही है।

— सनी

Answer 5

SQLiteDatabase ऑब्जेक्ट डेटाबेस पर ऑपरेशन के प्रकार पर निर्भर करता है।

अधिक जानकारी, आधिकारिक वेबसाइट पर जाएँ:

https://developer.android.com/training/basics/data-storage/databases.html#UpdateDbRow

यह बताता है कि SQLite डेटाबेस पर परामर्श में हेरफेर कैसे करें।

INSERT ROW

लिखने के मोड में डेटा भंडार हो जाता है

SQLiteDatabase db = mDbHelper.getWritableDatabase();

मानों का एक नया मानचित्र बनाएँ, जहाँ स्तंभ नाम कुंजियाँ हैं

ContentValues values = new ContentValues();
values.put(FeedEntry.COLUMN_NAME_ENTRY_ID, id);
values.put(FeedEntry.COLUMN_NAME_TITLE, title);
values.put(FeedEntry.COLUMN_NAME_CONTENT, content);

नई पंक्ति सम्मिलित करें, नई पंक्ति का प्राथमिक मुख्य मान लौटाते हुए

long newRowId;
newRowId = db.insert(
     FeedEntry.TABLE_NAME,
     FeedEntry.COLUMN_NAME_NULLABLE,
     values);

अद्यतन रो

परिभाषित करें 'जहां' क्वेरी का हिस्सा है।

String selection = FeedEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";

प्लेसहोल्डर ऑर्डर में तर्क निर्दिष्ट करें।

String[] selectionArgs = { String.valueOf(rowId) };


SQLiteDatabase db = mDbHelper.getReadableDatabase();

एक कॉलम के लिए नया मान

ContentValues values = new ContentValues();
values.put(FeedEntry.COLUMN_NAME_TITLE, title);

आईडी के आधार पर किस पंक्ति को अपडेट करना है

String selection = FeedEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
String[] selectionArgs = { String.valueOf(rowId) };
    int count = db.update(
    FeedReaderDbHelper.FeedEntry.TABLE_NAME,
    values,
    selection,
    selectionArgs);

Comments

यद्यपि लिंक की गई वेबसाइट में प्रश्न का उत्तर हो सकता है, लेकिन आपका उत्तर अधूरा लगता है। लिंक दूसरे तरीके से समाप्त हो सकते हैं या टूट सकते हैं। कृपया संबंधित वेबसाइट से अपने उत्तर में प्रासंगिक कोड / जानकारी जोड़ें।

— माइक

निश्चित रूप से मैं समझता हूं, मैंने अपने समाधान के लिए वस्तुतः मेरे कथित स्रोत के लिए काम किया, जहां मैंने प्राप्त किया

— गुस्तावो एडुआर्डो बेल्डुमा

Answer 6

मैं डेटाबेस को संभालने के लिए इस वर्ग का उपयोग करता हूं। मुझे उम्मीद है कि यह भविष्य में किसी एक की मदद करेगा।

खुश कोडिंग।

public class Database {

private static class DBHelper extends SQLiteOpenHelper {

    /**
     * Database name
     */
    private static final String DB_NAME = "db_name";

    /**
     * Table Names
     */
    public static final String TABLE_CART = "DB_CART";


    /**
     *  Cart Table Columns
     */
    public static final String CART_ID_PK = "_id";// Primary key

    public static final String CART_DISH_NAME = "dish_name";
    public static final String CART_DISH_ID = "menu_item_id";
    public static final String CART_DISH_QTY = "dish_qty";
    public static final String CART_DISH_PRICE = "dish_price";

    /**
     * String to create reservation tabs table
     */
    private final String CREATE_TABLE_CART = "CREATE TABLE IF NOT EXISTS "
            + TABLE_CART + " ( "
            + CART_ID_PK + " INTEGER PRIMARY KEY, "
            + CART_DISH_NAME + " TEXT , "
            + CART_DISH_ID + " TEXT , "
            + CART_DISH_QTY + " TEXT , "
            + CART_DISH_PRICE + " TEXT);";


    public DBHelper(Context context) {
        super(context, DB_NAME, null, 2);

    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(CREATE_TABLE_CART);


    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int arg1, int arg2) {
        db.execSQL("DROP TABLE IF EXISTS " + CREATE_TABLE_CART);
        onCreate(db);
    }

}


     /**
      * CART handler
      */
      public static class Cart {


    /**
     * Check if Cart is available or not
     *
     * @param context
     * @return
     */
    public static boolean isCartAvailable(Context context) {

        DBHelper dbHelper = new DBHelper(context);
        SQLiteDatabase db = dbHelper.getReadableDatabase();
        boolean exists = false;

        try {
            String query = "SELECT * FROM " + DBHelper.TABLE_CART;
            Cursor cursor = db.rawQuery(query, null);
            exists = (cursor.getCount() > 0);
            cursor.close();
            db.close();
        } catch (SQLiteException e) {
            db.close();
        }

        return exists;
    }


    /**
     * Insert values in cart table
     *
     * @param context
     * @param dishName
     * @param dishPrice
     * @param dishQty
     * @return
     */
    public static boolean insertItem(Context context, String itemId, String dishName, String dishPrice, String dishQty) {

        DBHelper dbHelper = new DBHelper(context);
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put(DBHelper.CART_DISH_ID, "" + itemId);
        values.put(DBHelper.CART_DISH_NAME, "" + dishName);
        values.put(DBHelper.CART_DISH_PRICE, "" + dishPrice);
        values.put(DBHelper.CART_DISH_QTY, "" + dishQty);

        try {
            db.insert(DBHelper.TABLE_CART, null, values);
            db.close();
            return true;
        } catch (SQLiteException e) {
            db.close();
            return false;
        }
    }

    /**
     * Check for specific record by name
     *
     * @param context
     * @param dishName
     * @return
     */
    public static boolean isItemAvailable(Context context, String dishName) {

        DBHelper dbHelper = new DBHelper(context);
        SQLiteDatabase db = dbHelper.getReadableDatabase();
        boolean exists = false;

        String query = "SELECT * FROM " + DBHelper.TABLE_CART + " WHERE "
                + DBHelper.CART_DISH_NAME + " = '" + String.valueOf(dishName) + "'";


        try {
            Cursor cursor = db.rawQuery(query, null);

            exists = (cursor.getCount() > 0);
            cursor.close();

        } catch (SQLiteException e) {

            e.printStackTrace();
            db.close();

        }

        return exists;
    }

    /**
     * Update cart item by item name
     *
     * @param context
     * @param dishName
     * @param dishPrice
     * @param dishQty
     * @return
     */
    public static boolean updateItem(Context context, String itemId, String dishName, String dishPrice, String dishQty) {

        DBHelper dbHelper = new DBHelper(context);
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put(DBHelper.CART_DISH_ID, itemId);
        values.put(DBHelper.CART_DISH_NAME, dishName);
        values.put(DBHelper.CART_DISH_PRICE, dishPrice);
        values.put(DBHelper.CART_DISH_QTY, dishQty);

        try {

            String[] args = new String[]{dishName};
            db.update(DBHelper.TABLE_CART, values, DBHelper.CART_DISH_NAME + "=?", args);

            db.close();


            return true;
        } catch (SQLiteException e) {
            db.close();

            return false;
        }
    }

    /**
     * Get cart list
     *
     * @param context
     * @return
     */
    public static ArrayList<CartModel> getCartList(Context context) {

        DBHelper dbHelper = new DBHelper(context);
        SQLiteDatabase db = dbHelper.getReadableDatabase();

        ArrayList<CartModel> cartList = new ArrayList<>();

        try {
            String query = "SELECT * FROM " + DBHelper.TABLE_CART + ";";

            Cursor cursor = db.rawQuery(query, null);


            for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {

                cartList.add(new CartModel(
                        cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_ID)),
                        cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_NAME)),
                        cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_QTY)),
                        Integer.parseInt(cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_PRICE)))
                ));
            }

            db.close();

        } catch (SQLiteException e) {
            db.close();
        }
        return cartList;
    }

   /**
     * Get total amount of cart items
     *
     * @param context
     * @return
     */
    public static String getTotalAmount(Context context) {

        DBHelper dbHelper = new DBHelper(context);
        SQLiteDatabase db = dbHelper.getReadableDatabase();

        double totalAmount = 0.0;

        try {
            String query = "SELECT * FROM " + DBHelper.TABLE_CART + ";";

            Cursor cursor = db.rawQuery(query, null);


            for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {

                totalAmount = totalAmount + Double.parseDouble(cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_PRICE))) *
                        Double.parseDouble(cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_QTY)));
            }

            db.close();


        } catch (SQLiteException e) {
            db.close();
        }


        if (totalAmount == 0.0)
            return "";
        else
            return "" + totalAmount;
    }


    /**
     * Get item quantity
     *
     * @param context
     * @param dishName
     * @return
     */
    public static String getItemQty(Context context, String dishName) {

        DBHelper dbHelper = new DBHelper(context);
        SQLiteDatabase db = dbHelper.getReadableDatabase();

        Cursor cursor = null;
        String query = "SELECT * FROM " + DBHelper.TABLE_CART + " WHERE " + DBHelper.CART_DISH_NAME + " = '" + dishName + "';";
        String quantity = "0";

        try {
            cursor = db.rawQuery(query, null);

            if (cursor.getCount() > 0) {

                cursor.moveToFirst();
                quantity = cursor.getString(cursor
                        .getColumnIndex(DBHelper.CART_DISH_QTY));

                return quantity;
            }


        } catch (SQLiteException e) {
            e.printStackTrace();
        }

        return quantity;
    }


    /**
     * Delete cart item by name
     *
     * @param context
     * @param dishName
     */
    public static void deleteCartItem(Context context, String dishName) {
        DBHelper dbHelper = new DBHelper(context);
        SQLiteDatabase db = dbHelper.getReadableDatabase();

        try {

            String[] args = new String[]{dishName};
            db.delete(DBHelper.TABLE_CART, DBHelper.CART_DISH_NAME + "=?", args);

            db.close();
        } catch (SQLiteException e) {
            db.close();
            e.printStackTrace();
        }

    }


}//End of cart class

/**
 * Delete database table
 *
 * @param context
 */
public static void deleteCart(Context context) {
    DBHelper dbHelper = new DBHelper(context);
    SQLiteDatabase db = dbHelper.getReadableDatabase();

    try {

        db.execSQL("DELETE FROM " + DBHelper.TABLE_CART);

    } catch (SQLiteException e) {
        e.printStackTrace();
    }

}

}

उपयोग:

  if(Database.Cart.isCartAvailable(context)){

       Database.deleteCart(context);

   }