Wie kann ich eine Spalte in SQLITE löschen oder hinzufügen?

ALTER TABLE SQLite

SQLite unterstützt nur eine begrenzte Teilmenge der ALTER TABLE-Anweisung. Die ALTER TABLE-Befehl in der SQLite-ermöglicht dem Benutzer das umbenennen einer Tabelle oder das hinzufügen einer neuen Spalte zu einer bestehenden Tabelle. Es ist nicht möglich, umbenennen einer Spalte entfernen eine Spalte, oder hinzufügen oder entfernen von Einschränkungen aus einer Tabelle.

Können Sie:

1. erstellen, neue Tabelle, die Sie ändern möchten,
2. kopieren Sie alle Daten,
3. drop Alter Tisch,
4. benennen Sie die neue.

InformationsquelleAutor der Antwort Michał Powaga

Als andere haben darauf hingewiesen,

Ist es nicht möglich, umbenennen einer Spalte entfernen eine Spalte, oder hinzufügen, oder
entfernen von Einschränkungen aus einer Tabelle.

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

Während Sie immer erstellen Sie eine neue Tabelle, und löschen Sie dann die ältere.
Ich werde versuchen zu erklären, diese Problemumgehung mit einem Beispiel.

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       

Nun wollen Sie zum entfernen der Spalte height aus dieser Tabelle.

Erstellen Sie eine weitere Tabelle namens new_person

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

Kopieren Sie nun die Daten aus der alten Tabelle

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>

Legen Sie nun die person Tabelle und benennen Sie new_person zu person

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

Also nun, wenn Sie ein .schema sehen Sie

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

InformationsquelleAutor der Antwort Tasdik Rahman

Können wir nicht fallen eine bestimmte Spalte in SQLite 3. Finden Sie die FAQ.

InformationsquelleAutor der Antwort sandeep valapishetty

Ich schrieb die @Udinic Antwort damit erzeugt der code zur Erstellung der Tabelle Abfrage automatisch. Es ist auch nicht brauchen ConnectionSource. Es hat auch dazu in einem Transaktion.

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


}

InformationsquelleAutor der Antwort soshial

Umsetzung in Python basiert auf Informationen, die bei http://www.sqlite.org/faq.html#q11.

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)

Diesem Skript wird zuerst macht zufällige temporäre Tabelle und fügt die Daten nur die notwendigen Spalten außer der, wird fallen gelassen werden. Stellt dann die original-Tabelle auf der Basis der temporären Tabelle und löscht die temporäre Tabelle.

InformationsquelleAutor der Antwort Akif

Als alternative:

Wenn Sie eine Tabelle mit schema

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

können Sie eine CREATE TABLE...AS Aussage wie CREATE TABLE person2 AS SELECT id, first_name, last_name, age FROM person;d.h. lassen sich die Spalten, die Sie nicht wollen. Löschen Sie anschließend den ursprünglichen person Tabelle und benennen Sie die neue.

Hinweis: diese Methode erzeugt eine Tabelle hat kein PRIMARY KEY und keine Einschränkungen. Zu erhalten, nutzen Sie die Methoden beschrieben andere, eine neue Tabelle zu erstellen, oder verwenden Sie eine temporäre Tabelle als Zwischenprodukt.

InformationsquelleAutor der Antwort karkarlawawa

können Sie Sqlitebrowser. Im browser-Modus, für die entsprechende Datenbank und die Tabelle unter der Registerkarte -Datenbank-Struktur,nach der option " Tabelle Ändern, jeweiligen Spalte entfernt werden konnte.

InformationsquelleAutor der Antwort iamigham

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

und nur eine Methode aufrufen

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

InformationsquelleAutor der Antwort Sagar Makhija

Habe ich verbessert user2638929 Antwort und jetzt kann es bewahrt Spalte Typ, Primärschlüssel und default-Wert etc.

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

PS. Habe ich hier android.arch.persistence.db.SupportSQLiteDatabaseaber Sie können leicht ändern, die Sie zur Nutzung android.database.sqlite.SQLiteDatabase

InformationsquelleAutor der Antwort Berdimurat Masaliev