SQLITE में कॉलम कैसे हटाएं या जोड़ें?


240

मैं sqlite डेटाबेस में कॉलम हटाना या जोड़ना चाहता हूं

कॉलम हटाने के लिए मैं निम्नलिखित क्वेरी का उपयोग कर रहा हूं।

ALTER TABLE TABLENAME DROP COLUMN COLUMNNAME

लेकिन यह त्रुटि देता है

System.Data.SQLite.SQLiteException: SQLite error
near "DROP": syntax error

जवाबों:


353

टॅबलेट SQLite

SQLite सीमित तालिका के सीमित उपसमूह का समर्थन करता है। SQLite में ALTER TABLE कमांड उपयोगकर्ता को एक तालिका का नाम बदलने या किसी मौजूदा तालिका में एक नया कॉलम जोड़ने की अनुमति देता है। एक स्तंभ का नाम बदलना, एक स्तंभ को हटाना, या एक तालिका से बाधाओं को जोड़ना या निकालना संभव नहीं है।

आप ऐसा कर सकते हैं:

  1. नई तालिका बनाएं, जिसे आप बदलने की कोशिश कर रहे हैं,
  2. सभी डेटा कॉपी करें,
  3. पुराना टेबल गिराओ,
  4. नया नाम बदलें।

47
stackoverflow.com/a/5987838/1578528 कार्य करने के लिए एक मूल उदाहरण देता है।
bikram990 5

4
इस क्रम को करने से पहले और ऐसे मामलों में जहां इस तालिका का जिक्र करने वाले बाहरी टेबल हैं, एक को कॉल करना होगा PRAGMA foreign_keys=OFF। इस मामले में, इस क्रम को करने के बाद किसी को PRAGMA foreign_keys=ONविदेशी कुंजियों को फिर से सक्षम करने के लिए कॉल करना होगा ।
PazO

आप फ्रीओइन कुंजी और सूचकांकों को भी कैसे कॉपी करते हैं?
जोनाथन

जब तक आप सेलेक्ट से क्रिएट करने के बजाय पहले एक नया टेबल बनाते हैं, तब तक वह सभी चीजें होंगी।
जॉन लॉर्ड

1
नए SQLite संस्करणों में, RENAME COLUMNसमर्थित है। 🎉 sqlite.org/releaselog/3_25_0.html
ग्रूज

46

मैंने ऐसा करने के लिए स्क्लाइट के अनुशंसित तरीके के आधार पर जावा कार्यान्वयन लिखा है:

private void dropColumn(SQLiteDatabase db,
        ConnectionSource connectionSource,
        String createTableCmd,
        String tableName,
        String[] colsToRemove) throws java.sql.SQLException {

    List<String> updatedTableColumns = getTableColumns(tableName);
    // Remove the columns we don't want anymore from the table's list of columns
    updatedTableColumns.removeAll(Arrays.asList(colsToRemove));

    String columnsSeperated = TextUtils.join(",", updatedTableColumns);

    db.execSQL("ALTER TABLE " + tableName + " RENAME TO " + tableName + "_old;");

    // Creating the table on its new format (no redundant columns)
    db.execSQL(createTableCmd);

    // Populating the table with the data
    db.execSQL("INSERT INTO " + tableName + "(" + columnsSeperated + ") SELECT "
            + columnsSeperated + " FROM " + tableName + "_old;");
    db.execSQL("DROP TABLE " + tableName + "_old;");
}

तालिका का कॉलम प्राप्त करने के लिए, मैंने "PRAGMA table_info" का उपयोग किया:

public List<String> getTableColumns(String tableName) {
    ArrayList<String> columns = new ArrayList<String>();
    String cmd = "pragma table_info(" + tableName + ");";
    Cursor cur = getDB().rawQuery(cmd, null);

    while (cur.moveToNext()) {
        columns.add(cur.getString(cur.getColumnIndex("name")));
    }
    cur.close();

    return columns;
}

मैंने वास्तव में अपने ब्लॉग पर इसके बारे में लिखा था, आप वहां और स्पष्टीकरण देख सकते हैं:

http://udinic.wordpress.com/2012/05/09/sqlite-drop-column-support/


1
यह बहुत धीमी है, हालांकि यह नहीं है? बड़े डेटा तालिकाओं के लिए?
जोरन बेस्ले

2
यह बेहतर होगा यदि यह एक लेनदेन में किया गया था, बल्कि संभावित रूप से अन्य कोड को संक्रमणकालीन स्थिति में चीजों को देखने की अनुमति देता है।
डोनाल्ड फेलो

यह कोड मैं आमतौर पर डीबी को अपग्रेड करते समय चलाता है, जहां अन्य कोड एक साथ नहीं चल रहे हैं। आप एक लेन-देन बना सकते हैं और उसमें सभी कमांड कर सकते हैं।
उदिनिक

3
मुझे पूरा यकीन है कि यदि आप इस समाधान का उपयोग करते हैं तो आपकी परिणाम तालिका पर कॉलम पूरी तरह से नंगे होंगे - कोई प्रकार की जानकारी, पीके, एफके, डिफ़ॉल्ट मान, अद्वितीय या चेक बाधाएं नहीं रहेंगी। यह सभी नई तालिका में आयात कॉलम नाम है। इसके अलावा, चूंकि यह चलने से पहले विदेशी कुंजी को अक्षम नहीं करता है, इसलिए अन्य तालिकाओं में डेटा भी खराब हो सकता है।
ACK_stoverflow

4
वैकल्पिक रूप से, एक INSERTबयान करने के बजाय , आप "CREAT TABLE" + tableName + "AS SELECT " + columnsSeperated + " FROM " + tableName + "_old;"
रॉबर्ट

26

जैसा कि दूसरों ने बताया है

एक स्तंभ का नाम बदलना, एक स्तंभ को हटाना, या एक तालिका से बाधाओं को जोड़ना या निकालना संभव नहीं है।

स्रोत: http://www.sqlite.org/lang_altertable.html

जबकि आप हमेशा एक नई तालिका बना सकते हैं और फिर पुराने को छोड़ सकते हैं। मैं इस वर्कअराउंड को एक उदाहरण के साथ समझाने की कोशिश करूंगा ।

sqlite> .schema
CREATE TABLE person(
 id INTEGER PRIMARY KEY, 
 first_name TEXT,
 last_name TEXT, 
 age INTEGER, 
 height INTEGER
);
sqlite> select * from person ; 
id          first_name  last_name   age         height    
----------  ----------  ----------  ----------  ----------
0           john        doe         20          170       
1           foo         bar         25          171       

अब आप heightइस तालिका से कॉलम हटाना चाहते हैं ।

नामक एक और तालिका बनाएँ new_person

sqlite> CREATE TABLE new_person(
   ...>  id INTEGER PRIMARY KEY, 
   ...>  first_name TEXT, 
   ...>  last_name TEXT, 
   ...>  age INTEGER 
   ...> ) ; 
sqlite> 

अब पुराने टेबल से डेटा कॉपी करें

sqlite> INSERT INTO new_person
   ...> SELECT id, first_name, last_name, age FROM person ;
sqlite> select * from new_person ;
id          first_name  last_name   age       
----------  ----------  ----------  ----------
0           john        doe         20        
1           foo         bar         25        
sqlite>

अब ड्रॉप personतालिका और नाम बदलने new_personके लिएperson

sqlite> DROP TABLE IF EXISTS person ; 
sqlite> ALTER TABLE new_person RENAME TO person ;
sqlite>

तो अब यदि आप एक करते हैं .schema, तो आप देखेंगे

sqlite>.schema
CREATE TABLE "person"(
 id INTEGER PRIMARY KEY, 
 first_name TEXT, 
 last_name TEXT, 
 age INTEGER 
);

विदेशी संदर्भों के बारे में क्या? यदि आप किसी अन्य तालिका का उपयोग कर रहे हैं जो तालिका को हटाते हैं, तो Oracle शिकायत करेगा।
लेओस लिटरक जूल

6
मैं बता सकता हूं कि आप एक वास्तविक प्रोग्रामर हैं। आप जॉन डो के ठीक बाद नामों से भाग गए और सीधे "फू बार" चले गए :)
msouth

1
CREATE TABLE new_person AS SELECT id, first_name, last_name, age FROM person;
क्ले

12

http://www.sqlite.org/lang_altertable.html

जैसा कि आप आरेख में देख सकते हैं, केवल ADD COLUMN समर्थित है। हालांकि (थोड़े भारी) वर्कअराउंड है, हालांकि: http://www.sqlite.org/faq.html#q11


"वर्कअराउंड" बस सही नहीं लगता है। आप स्तंभ प्रकार, अवरोध, सूचकांक और क्या नहीं खो रहे हैं।
केनेट जुरेक्ट


4

जैसा कि अन्य ने बताया है, साइक्लाइट का ALTER TABLEकथन समर्थन नहीं करता है DROP COLUMN, और ऐसा करने के लिए मानक नुस्खा बाधाओं और सूचकांकों को संरक्षित नहीं करता है।

सभी प्रमुख बाधाओं और सूचकांकों को बनाए रखते हुए, यह उदारता से करने के लिए कुछ अजगर कोड है ।

उपयोग करने से पहले अपने डेटाबेस का बैक-अप करें! यह फ़ंक्शन मूल क्रिएट टेबल स्टेटमेंट को डॉक्टरेट करने पर निर्भर करता है और संभवतः थोड़ा असुरक्षित है - उदाहरण के लिए यह गलत काम करेगा यदि एक पहचानकर्ता में एक एम्बेडेड कॉमा या कोष्ठक होता है।

अगर कोई भी SQL को पार्स करने के लिए बेहतर तरीके से योगदान करने की परवाह करेगा, तो यह बहुत अच्छा होगा!

अद्यतन मुझे ओपन-सोर्सsqlparseपैकेजका उपयोग करके पार्स करने का एक बेहतर तरीका मिला। अगर कोई रुचि है तो मैं इसे यहां पोस्ट करूंगा, बस एक टिप्पणी छोड़ दो इसके लिए पूछ रहा हूं ...

import re
import random

def DROP_COLUMN(db, table, column):
    columns = [ c[1] for c in db.execute("PRAGMA table_info(%s)" % table) ]
    columns = [ c for c in columns if c != column ]
    sql = db.execute("SELECT sql from sqlite_master where name = '%s'" 
        % table).fetchone()[0]
    sql = format(sql)
    lines = sql.splitlines()
    findcol = r'\b%s\b' % column
    keeplines = [ line for line in lines if not re.search(findcol, line) ]
    create = '\n'.join(keeplines)
    create = re.sub(r',(\s*\))', r'\1', create)
    temp = 'tmp%d' % random.randint(1e8, 1e9)
    db.execute("ALTER TABLE %(old)s RENAME TO %(new)s" % { 
        'old': table, 'new': temp })
    db.execute(create)
    db.execute("""
        INSERT INTO %(new)s ( %(columns)s ) 
        SELECT %(columns)s FROM %(old)s
    """ % { 
        'old': temp,
        'new': table,
        'columns': ', '.join(columns)
    })  
    db.execute("DROP TABLE %s" % temp)

def format(sql):
    sql = sql.replace(",", ",\n")
    sql = sql.replace("(", "(\n")
    sql = sql.replace(")", "\n)")
    return sql

क्या यह टेबल पर विदेशी कुंजी भी रखता है?
लास वी। कार्लसन

@ LasseV.Karlsen मैंने कुछ परीक्षण किए और इसे विदेशी प्रमुख बाधाओं को बनाए रखना चाहिए क्योंकि ये तालिका नाम से लागू होते हैं।
spam_eggs

मैं इसे जावा से कैसे चला सकता हूं?
लीओस लिटरक

4

मैं @ यूडिक उत्तर फिर से लिखता हूं ताकि कोड तालिका निर्माण क्वेरी को स्वचालित रूप से उत्पन्न करे । इसकी भी जरूरत नहीं है ConnectionSource। यह भी एक लेनदेन के अंदर यह करना है ।

public static String getOneTableDbSchema(SQLiteDatabase db, String tableName) {
    Cursor c = db.rawQuery(
            "SELECT * FROM `sqlite_master` WHERE `type` = 'table' AND `name` = '" + tableName + "'", null);
    String result = null;
    if (c.moveToFirst()) {
        result = c.getString(c.getColumnIndex("sql"));
    }
    c.close();
    return result;
}

public List<String> getTableColumns(SQLiteDatabase db, String tableName) {
    ArrayList<String> columns = new ArrayList<>();
    String cmd = "pragma table_info(" + tableName + ");";
    Cursor cur = db.rawQuery(cmd, null);

    while (cur.moveToNext()) {
        columns.add(cur.getString(cur.getColumnIndex("name")));
    }
    cur.close();

    return columns;
}

private void dropColumn(SQLiteDatabase db, String tableName, String[] columnsToRemove) {
    db.beginTransaction();
    try {
        List<String> columnNamesWithoutRemovedOnes = getTableColumns(db, tableName);
        // Remove the columns we don't want anymore from the table's list of columns
        columnNamesWithoutRemovedOnes.removeAll(Arrays.asList(columnsToRemove));

        String newColumnNamesSeparated = TextUtils.join(" , ", columnNamesWithoutRemovedOnes);
        String sql = getOneTableDbSchema(db, tableName);
        // Extract the SQL query that contains only columns
        String oldColumnsSql = sql.substring(sql.indexOf("(")+1, sql.lastIndexOf(")"));

        db.execSQL("ALTER TABLE " + tableName + " RENAME TO " + tableName + "_old;");
        db.execSQL("CREATE TABLE `" + tableName + "` (" + getSqlWithoutRemovedColumns(oldColumnsSql, columnsToRemove)+ ");");
        db.execSQL("INSERT INTO " + tableName + "(" + newColumnNamesSeparated + ") SELECT " + newColumnNamesSeparated + " FROM " + tableName + "_old;");
        db.execSQL("DROP TABLE " + tableName + "_old;");
        db.setTransactionSuccessful();
    } catch {
        //Error in between database transaction 
    } finally {
        db.endTransaction();
    }


}

3

SQLite के लिए DB ब्राउज़र आपको कॉलम जोड़ने या छोड़ने की अनुमति देता है।

मुख्य दृश्य में, टैब Database Structure, तालिका के नाम पर क्लिक करें। एक बटन Modify Tableसक्षम हो जाता है, जो एक नई विंडो खोलता है जहां आप कॉलम / फ़ील्ड का चयन कर सकते हैं और इसे हटा सकते हैं।


2

आप Sqlitebrowser का उपयोग कर सकते हैं। संबंधित मोड और तालिका के लिए ब्राउज़र मोड में, टैब -database संरचना के तहत, विकल्प संशोधित करें तालिका के बाद, संबंधित कॉलम को हटाया जा सकता है।


2

मैंने user2638929 उत्तर में सुधार किया है और अब यह कॉलम प्रकार, प्राथमिक कुंजी, डिफ़ॉल्ट मान आदि को संरक्षित कर सकता है।

private static void dropColumn(SupportSQLiteDatabase database, String tableName, List<String> columnsToRemove){
    List<String> columnNames = new ArrayList<>();
    List<String> columnNamesWithType = new ArrayList<>();
    List<String> primaryKeys = new ArrayList<>();
    String query = "pragma table_info(" + tableName + ");";
    Cursor cursor = database.query(query);
    while (cursor.moveToNext()){
        String columnName = cursor.getString(cursor.getColumnIndex("name"));

        if (columnsToRemove.contains(columnName)){
            continue;
        }

        String columnType = cursor.getString(cursor.getColumnIndex("type"));
        boolean isNotNull = cursor.getInt(cursor.getColumnIndex("notnull")) == 1;
        boolean isPk = cursor.getInt(cursor.getColumnIndex("pk")) == 1;

        columnNames.add(columnName);
        String tmp = "`" + columnName + "` " + columnType + " ";
        if (isNotNull){
            tmp += " NOT NULL ";
        }

        int defaultValueType = cursor.getType(cursor.getColumnIndex("dflt_value"));
        if (defaultValueType == Cursor.FIELD_TYPE_STRING){
            tmp += " DEFAULT " + "\"" + cursor.getString(cursor.getColumnIndex("dflt_value")) + "\" ";
        }else if(defaultValueType == Cursor.FIELD_TYPE_INTEGER){
            tmp += " DEFAULT " + cursor.getInt(cursor.getColumnIndex("dflt_value")) + " ";
        }else if (defaultValueType == Cursor.FIELD_TYPE_FLOAT){
            tmp += " DEFAULT " + cursor.getFloat(cursor.getColumnIndex("dflt_value")) + " ";
        }
        columnNamesWithType.add(tmp);
        if (isPk){
            primaryKeys.add("`" + columnName + "`");
        }
    }
    cursor.close();

    String columnNamesSeparated = TextUtils.join(", ", columnNames);
    if (primaryKeys.size() > 0){
        columnNamesWithType.add("PRIMARY KEY("+ TextUtils.join(", ", primaryKeys) +")");
    }
    String columnNamesWithTypeSeparated = TextUtils.join(", ", columnNamesWithType);

    database.beginTransaction();
    try {
        database.execSQL("ALTER TABLE " + tableName + " RENAME TO " + tableName + "_old;");
        database.execSQL("CREATE TABLE " + tableName + " (" + columnNamesWithTypeSeparated + ");");
        database.execSQL("INSERT INTO " + tableName + " (" + columnNamesSeparated + ") SELECT "
                + columnNamesSeparated + " FROM " + tableName + "_old;");
        database.execSQL("DROP TABLE " + tableName + "_old;");
        database.setTransactionSuccessful();
    }finally {
        database.endTransaction();
    }
}

पुनश्च। मैंने यहां उपयोग किया है android.arch.persistence.db.SupportSQLiteDatabase, लेकिन आप इसे आसानी से उपयोग के लिए संशोधित कर सकते हैंandroid.database.sqlite.SQLiteDatabase


2

मुझे लगता है कि आप जो करना चाहते हैं वह डेटाबेस माइग्रेशन है। SQLite में एक कॉलम ड्रॉपिंग मौजूद नहीं है। लेकिन आप हालांकि, ALTER टेबल क्वेरी का उपयोग करके एक अतिरिक्त कॉलम जोड़ सकते हैं।


1

कॉलम नाम बदलने के लिए आप SQlite एडमिनिस्ट्रेटर का उपयोग कर सकते हैं। तालिका के नाम पर राइट क्लिक करें और संपादित करें तालिका का चयन करें। आपको तालिका संरचना मिल जाएगी और आप आसानी से इसका नाम बदल सकते हैं।


1

चूंकि SQLite में ALTER TABLE के लिए सीमित समर्थन है, इसलिए आप तालिका के अंत में केवल ADD कॉलम जोड़ सकते हैं या SQLite में TABLE_NAME को बदल सकते हैं।

यहाँ SQLite से कैसे रंग का सबसे अच्छा जवाब है?

पर जाएँ SQLite मेज से हटाएं स्तंभ


1

विकल्प के रूप में:

यदि आपके पास स्कीमा के साथ एक तालिका है

CREATE TABLE person(
  id INTEGER PRIMARY KEY,
  first_name TEXT,
  last_name TEXT,
  age INTEGER,
  height INTEGER
);

आप एक CREATE TABLE...ASकथन का उपयोग कर सकते हैं CREATE TABLE person2 AS SELECT id, first_name, last_name, age FROM person;, जैसे कि आप जो कॉलम नहीं चाहते हैं उन्हें छोड़ दें। फिर मूल personतालिका ड्रॉप करें और नया नाम बदलें।

ध्यान दें कि यह विधि एक तालिका बनाती है जिसमें कोई प्राथमिक कुंजी नहीं है और कोई बाधा नहीं है। उन्हें संरक्षित करने के लिए, नई तालिका बनाने के लिए वर्णित अन्य विधियों का उपयोग करें, या एक अस्थायी तालिका का उपयोग मध्यवर्ती के रूप में करें।


1

एक अलग प्रश्न का यह उत्तर एक कॉलम को संशोधित करने की दिशा में उन्मुख है , लेकिन मेरा मानना ​​है कि उत्तर का एक भाग भी उपयोगी दृष्टिकोण प्राप्त कर सकता है यदि आपके पास बहुत सारे कॉलम हैं और अपने INSERT स्टेटमेंट के लिए उनमें से अधिकांश को फिर से लिखना नहीं चाहते हैं:

https://stackoverflow.com/a/10385666

आप ऊपर दिए गए लिंक में वर्णित के रूप में अपने डेटाबेस को डंप कर सकते हैं, फिर "डंप टेबल बनाएं" स्टेटमेंट और उस डंप से एक "इंसर्ट" टेम्पलेट को पकड़ो, फिर SQLite FAQ प्रविष्टि में दिए गए निर्देशों का पालन करें "मैं मौजूदा से कॉलम कैसे जोड़ूं या हटाऊं?" SQLite में तालिका। " (अक्सर पूछे जाने वाले प्रश्न इस पृष्ठ पर कहीं और जुड़े हैं।)


वास्तव में, मुझे बस एहसास हुआ कि डंप डिफ़ॉल्ट रूप से सम्मिलित करने में स्तंभ नाम शामिल नहीं करता है। इसलिए कॉलम नामों को हथियाने के लिए .schem pragma का उपयोग करना भी उतना ही अच्छा हो सकता है, क्योंकि तब आपको किसी भी तरह से घोषणाओं को हटाने की आवश्यकता होगी।
burpgrass

1

Http://www.sqlite.org/faq.html#q11Python पर जानकारी के आधार पर कार्यान्वयन ।

import sqlite3 as db
import random
import string

QUERY_TEMPLATE_GET_COLUMNS = "PRAGMA table_info(@table_name)"
QUERY_TEMPLATE_DROP_COLUMN = """
  BEGIN TRANSACTION;
  CREATE TEMPORARY TABLE @tmp_table(@columns_to_keep);
  INSERT INTO @tmp_table SELECT @columns_to_keep FROM @table_name;
  DROP TABLE @table_name;
  CREATE TABLE @table_name(@columns_to_keep);
  INSERT INTO @table_name SELECT @columns_to_keep FROM @tmp_table;
  DROP TABLE @tmp_table;
  COMMIT;
"""

def drop_column(db_file, table_name, column_name):
    con = db.connect(db_file)
    QUERY_GET_COLUMNS = QUERY_TEMPLATE_GET_COLUMNS.replace("@table_name", table_name)
    query_res = con.execute(QUERY_GET_COLUMNS).fetchall()
    columns_list_to_keep = [i[1] for i in query_res if i[1] != column_name]
    columns_to_keep = ",".join(columns_list_to_keep)
    tmp_table = "tmp_%s" % "".join(random.sample(string.ascii_lowercase, 10))
    QUERY_DROP_COLUMN = QUERY_TEMPLATE_DROP_COLUMN.replace("@table_name", table_name)\
        .replace("@tmp_table", tmp_table).replace("@columns_to_keep", columns_to_keep)
    con.executescript(QUERY_DROP_COLUMN)
    con.close()

drop_column(DB_FILE, TABLE_NAME, COLUMN_NAME)

यह स्क्रिप्ट पहले यादृच्छिक अस्थायी तालिका बनाती है और केवल आवश्यक कॉलम का डेटा सम्मिलित करती है सिवाय इसके कि उसे छोड़ दिया जाएगा। फिर अस्थायी तालिका के आधार पर मूल तालिका को पुनर्स्थापित करता है और अस्थायी तालिका को छोड़ देता है।


1

मेरा समाधान, केवल इस पद्धति को कॉल करने की आवश्यकता है।

public static void dropColumn(SQLiteDatabase db, String tableName, String[] columnsToRemove) throws java.sql.SQLException {
    List<String> updatedTableColumns = getTableColumns(db, tableName);
    updatedTableColumns.removeAll(Arrays.asList(columnsToRemove));
    String columnsSeperated = TextUtils.join(",", updatedTableColumns);

    db.execSQL("ALTER TABLE " + tableName + " RENAME TO " + tableName + "_old;");
    db.execSQL("CREATE TABLE " + tableName + " (" + columnsSeperated + ");");
    db.execSQL("INSERT INTO " + tableName + "(" + columnsSeperated + ") SELECT "
            + columnsSeperated + " FROM " + tableName + "_old;");
    db.execSQL("DROP TABLE " + tableName + "_old;");
}

और कॉलम पाने के लिए सहायक विधि:

public static List<String> getTableColumns(SQLiteDatabase db, String tableName) {
    ArrayList<String> columns = new ArrayList<>();
    String cmd = "pragma table_info(" + tableName + ");";
    Cursor cur = db.rawQuery(cmd, null);

    while (cur.moveToNext()) {
        columns.add(cur.getString(cur.getColumnIndex("name")));
    }
    cur.close();

    return columns;
}

यह विधि कोलनम प्रकार को नहीं रखती है, इसलिए मैंने आपके कोड का संशोधित संस्करण पोस्ट किया
बर्दिमिरत मसालिव जूल

0
public void DeleteColFromTable(String DbName, String TableName, String ColName){
    SQLiteDatabase db = openOrCreateDatabase(""+DbName+"", Context.MODE_PRIVATE, null);
    db.execSQL("CREATE TABLE IF NOT EXISTS "+TableName+"(1x00dff);");
    Cursor c = db.rawQuery("PRAGMA table_info("+TableName+")", null);
    if (c.getCount() == 0) {

    } else {
        String columns1 = "";
        String columns2 = "";
        while (c.moveToNext()) {
            if (c.getString(1).equals(ColName)) {
            } else {
                columns1 = columns1 + ", " + c.getString(1) + " " + c.getString(2);
                columns2 = columns2 + ", " + c.getString(1);
            }
            if (c.isLast()) {
                db.execSQL("CREATE TABLE IF NOT EXISTS DataBackup (" + columns1 + ");");
                db.execSQL("INSERT INTO DataBackup SELECT " + columns2 + " FROM "+TableName+";");
                db.execSQL("DROP TABLE "+TableName+"");
                db.execSQL("ALTER TABLE DataBackup RENAME TO "+TableName+";");
            }
        }
    }
}

और बस एक विधि कहते हैं

DeleteColFromTable("Database name","Table name","Col name which want to delete");

-1

आप अब कॉलम को मैनिपुलेट करने के लिए SQLite के लिए DB ब्राउज़र का भी उपयोग कर सकते हैं


-2

स्तंभ जोड़ने के लिए उदाहरण: -

alter table student add column TOB time;

यहां छात्र है TABLE_NAME और TOB है स्तंभ जोड़े जाने के लिए।

यह काम कर रहा है और परीक्षण किया है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.