Android SQLite数据库崩溃

我的数据库中的一个表有问题。 问题在于移动表： 每当我插入某个动作时，它都能正常工作，但当我试图检索某个动作时，我的应用程序崩溃了

我不知道我做错了什么，基本上和客户表完全一样

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

import java.util.ArrayList;
import java.util.List;

public class DatabaseHandler extends SQLiteOpenHelper {

    private static final int DATABASE_VERSION = 1;

    private static final String DATABASE_NAME = "ClientsManager";

    private static final String CLIENTS_TABLE = "Clients";
    private static final String MOVEMENTS_TABLE = "Movements";

    //Client Table Columns
    private static final String KEY_ROWID = "numint";
    private static final String KEY_NAME = "name";
    private static final String KEY_LOCAL = "locality";
    private static final String KEY_ADDR = "address";
    private static final String KEY_BTTLP = "bottle_price";
    private static final String KEY_PBLNC = "prev_balance";
    private static final String KEY_BLNC = "balance";
    private static final String KEY_BBTTLS = "bonif_bottles";
    private static final String KEY_PBTTLS = "prev_bottles";
    private static final String KEY_BTTLS = "bottles";
    private static final String KEY_SYNC = "sync_date";
    private static final String KEY_MODIF = "modif_date";

    //Movements Table Columns
    private static final String MKEY_ROWID = "numint";
    private static final String MKEY_ID_MOVE = "move_id";
    private static final String MKEY_CLIENT_ID = "client_id";
    private static final String MKEY_PICKUP = "pickup";
    private static final String MKEY_DELIVER = "deliver";
    private static final String MKEY_PAYMENT = "payment";
    private static final String MKEY_MOVE_DATE = "move_date";
    private static final String MKEY_SYNC_DATE = "sync_date";
    private static final String MKEY_FLAG_SYNC = "flag_sync";


    public DatabaseHandler(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase) {
        String CREATE_CLIENTS_TABLE = "CREATE TABLE " + CLIENTS_TABLE + "("
                + KEY_ROWID + " INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "
                + KEY_NAME + " TEXT NOT NULL, "
                + KEY_LOCAL + " TEXT NOT NULL, "
                + KEY_ADDR + " TEXT NOT NULL, "
                + KEY_BTTLP + " REAL NOT NULL, "
                + KEY_PBLNC + " REAL NOT NULL, "
                + KEY_BLNC + " REAL NOT NULL, "
                + KEY_BBTTLS + " INTEGER NOT NULL, "
                + KEY_PBTTLS + " INTEGER NOT NULL, "
                + KEY_BTTLS + " INTEGER NOT NULL, "
                + KEY_SYNC + " TEXT NOT NULL, "
                + KEY_MODIF + " TEXT NOT NULL )";

        String CREATE_MOVEMENTS_TABLE = "CREATE TABLE " + MOVEMENTS_TABLE + "("
                + MKEY_ROWID + " INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "
                + MKEY_ID_MOVE + " TEXT NOT NULL, "
                + MKEY_CLIENT_ID + " INTEGER NOT NULL, "
                + MKEY_PICKUP + " INTEGER NOT NULL, "
                + MKEY_DELIVER + " INTEGER NOT NULL, "
                + MKEY_PAYMENT + " REAL NOT NULL, "
                + MKEY_MOVE_DATE + " TEXT NOT NULL, "
                + MKEY_SYNC_DATE + " TEXT NOT NULL, "
                + MKEY_FLAG_SYNC + " INTEGER NOT NULL )";

        sqLiteDatabase.execSQL(CREATE_CLIENTS_TABLE);
        sqLiteDatabase.execSQL(CREATE_MOVEMENTS_TABLE);
    }

    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
        sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + CLIENTS_TABLE);
        sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + MOVEMENTS_TABLE);
        onCreate(sqLiteDatabase);
    }

    public void addClient(Client client) {
        SQLiteDatabase db = this.getWritableDatabase();

        ContentValues values = new ContentValues();

        values.put(KEY_NAME, client.getName());
        values.put(KEY_LOCAL, client.getLocality());
        values.put(KEY_ADDR, client.getAddress());
        values.put(KEY_BTTLP, client.getBottlePrice());
        values.put(KEY_PBLNC, client.getPrevBalance());
        values.put(KEY_BLNC, client.getBalance());
        values.put(KEY_BBTTLS, client.getBonifBottles());
        values.put(KEY_PBTTLS, client.getPrevBottles());
        values.put(KEY_BTTLS, client.getBottles());
        values.put(KEY_SYNC, client.getSyncDate());
        values.put(KEY_MODIF, client.getModifDate());

        //Insert row
        db.insert(CLIENTS_TABLE, null, values);
        db.close();
    }

    public Client getClient(int id) {
        SQLiteDatabase db = this.getReadableDatabase();

        Cursor cursor = db.query(CLIENTS_TABLE, new String[] { KEY_ROWID, KEY_NAME, KEY_LOCAL,
                KEY_ADDR, KEY_BTTLP, KEY_PBLNC, KEY_BLNC, KEY_BBTTLS, KEY_PBTTLS, KEY_BTTLS, KEY_SYNC, KEY_MODIF}, KEY_ROWID + "=?",
                new String[] {String.valueOf(id)}, null, null, null, null);

        if(cursor != null) {
            cursor.moveToFirst();
        }

        Client client = new Client(Integer.parseInt(cursor.getString(0)), cursor.getString(1), cursor.getString(2),
                cursor.getString(3), Float.parseFloat(cursor.getString(4)), Float.parseFloat(cursor.getString(5)),
                Float.parseFloat(cursor.getString(6)), Integer.parseInt(cursor.getString(7)), Integer.parseInt(cursor.getString(8)),
                Integer.parseInt(cursor.getString(9)), cursor.getString(10), cursor.getString(11));

        return client;
    }

    public List<Client> getAllClients() {
        List<Client> clientList = new ArrayList<Client>();

        String selectQuery = "SELECT * FROM " + CLIENTS_TABLE;

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor cursor = db.rawQuery(selectQuery, null);

        if(cursor.moveToFirst()) {
            do {

                Client client = new Client(Integer.parseInt(cursor.getString(0)), cursor.getString(1), cursor.getString(2),
                        cursor.getString(3), Float.parseFloat(cursor.getString(4)), Float.parseFloat(cursor.getString(5)),
                        Float.parseFloat(cursor.getString(6)), Integer.parseInt(cursor.getString(7)), Integer.parseInt(cursor.getString(8)),
                        Integer.parseInt(cursor.getString(9)), cursor.getString(10), cursor.getString(11));

                clientList.add(client);

            }while(cursor.moveToNext());
        }

        return clientList;
    }

    public int getClientCount() {
        String countQuery = "SELECT * FROM " + CLIENTS_TABLE;
        SQLiteDatabase db = this.getReadableDatabase();
        Cursor cursor = db.rawQuery(countQuery, null);
        cursor.close();

        return cursor.getCount();
    }

    public int updateClient(Client client) {

        SQLiteDatabase db = this.getWritableDatabase();

        ContentValues values = new ContentValues();
        values.put(KEY_PBLNC, client.getPrevBalance());
        values.put(KEY_BLNC, client.getBalance());
        values.put(KEY_PBTTLS, client.getPrevBottles());
        values.put(KEY_BTTLS, client.getBottles());
        values.put(KEY_MODIF, client.getModifDate());

        return db.update(CLIENTS_TABLE, values, KEY_ROWID + "=?",
                new String[] {String.valueOf(client.getId())});
    }

    public int deleteClient(Client client) {
        int count = 0;
        SQLiteDatabase db = this.getWritableDatabase();
        count = db.delete(CLIENTS_TABLE, KEY_ROWID + "=?", new String[] {String.valueOf(client.getId())});
        db.close();

        return count;
    }

    public int deleteAllClients() {
        List<Client> clientList = getAllClients();
        SQLiteDatabase db = this.getWritableDatabase();
        int count = 0;
        for(int i = 0; i < clientList.size(); i++) {
            count += db.delete(CLIENTS_TABLE, KEY_ROWID + "=?", new String[] {String.valueOf(clientList.get(i).getId())});
        }

        return  count;
    }

    public void addMovement(Movement movement) {

        SQLiteDatabase db = this.getWritableDatabase();

        ContentValues values = new ContentValues();
        values.put(MKEY_ID_MOVE, movement.getMoveId());
        values.put(MKEY_CLIENT_ID, movement.getClientId());
        values.put(MKEY_PICKUP, movement.getPickUp());
        values.put(MKEY_DELIVER, movement.getDeliver());
        values.put(MKEY_PAYMENT, movement.getPayment());
        values.put(MKEY_MOVE_DATE, movement.getMoveDate());
        values.put(MKEY_SYNC_DATE, movement.getSyncDate());
        values.put(MKEY_FLAG_SYNC, movement.getFlagSync());

        db.insert(MOVEMENTS_TABLE, null, values);
        db.close();
    }

    public Movement getMovement(int clientId) {
        SQLiteDatabase db = this.getReadableDatabase();

        Cursor cursor = db.query(MOVEMENTS_TABLE, new String[] {MKEY_ROWID, MKEY_ID_MOVE, MKEY_CLIENT_ID,
        MKEY_PICKUP, MKEY_DELIVER, MKEY_PAYMENT, MKEY_MOVE_DATE, MKEY_SYNC_DATE, MKEY_SYNC_DATE}, MKEY_CLIENT_ID + "=?",
                 new String[] {String.valueOf(clientId)}, null, null, null, null);

        Movement movement = null;

        if(cursor != null) {
            if(cursor.moveToFirst()) {
                movement = new Movement(Integer.parseInt(cursor.getString(0)), cursor.getString(1), Integer.parseInt(cursor.getString(2)),
                        Integer.parseInt(cursor.getString(3)), Integer.parseInt(cursor.getString(4)), Float.parseFloat(cursor.getString(5)),
                        cursor.getString(6), cursor.getString(7), Integer.parseInt(cursor.getString(8)));
            }
        }

        return movement;
    }

    public List<Movement> getAllMovements() {
        List<Movement> movementList = new ArrayList<Movement>();

        String query = "SELECT * FROM " + MOVEMENTS_TABLE;

        SQLiteDatabase db = this.getReadableDatabase();

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

        if(cursor.moveToFirst()) {
            do {

                Movement movement = new Movement(Integer.parseInt(cursor.getString(0)), cursor.getString(1), Integer.parseInt(cursor.getString(2)),
                        Integer.parseInt(cursor.getString(3)), Integer.parseInt(cursor.getString(4)), Float.parseFloat(cursor.getString(5)),
                        cursor.getString(6), cursor.getString(7), Integer.parseInt(cursor.getString(8)));

                movementList.add(movement);

            }while (cursor.moveToNext());
        }

        return movementList;
    }

    public int deleteAllMovements() {
        SQLiteDatabase db = this.getWritableDatabase();
        List<Movement> movementList = getAllMovements();

        int count = 0;

        for(int i = 0; i < movementList.size(); i++) {
            count += db.delete(MOVEMENTS_TABLE, MKEY_ROWID + "=?", new String[] {String.valueOf(movementList.get(i).getId())});
        }

        return count;
    }

    public int updateMovement(Movement movement) {
        SQLiteDatabase db = this.getWritableDatabase();

        ContentValues values = new ContentValues();
        values.put(MKEY_PICKUP, movement.getPickUp());
        values.put(MKEY_DELIVER, movement.getDeliver());
        values.put(MKEY_PAYMENT, movement.getPayment());
        values.put(MKEY_MOVE_DATE, movement.getMoveDate());

        return db.update(MOVEMENTS_TABLE, values, MKEY_ROWID + "=?", new String[] {String.valueOf(movement.getId())});

    }

}

导入android.content.ContentValues；
导入android.content.Context；
导入android.database.Cursor；
导入android.database.sqlite.SQLiteDatabase；
导入android.database.sqlite.SQLiteOpenHelper；
导入java.util.ArrayList；
导入java.util.List；
公共类DatabaseHandler扩展了SQLiteOpenHelper{
私有静态最终int数据库_VERSION=1；
私有静态最终字符串数据库\u NAME=“ClientsManager”；
私有静态最终字符串客户端\u TABLE=“CLIENTS”；
私有静态最终字符串移动\u TABLE=“移动”；
//客户端表列
私有静态最终字符串键\u ROWID=“numint”；
私有静态最终字符串键\u NAME=“NAME”；
私有静态最终字符串密钥\u LOCAL=“locality”；
私有静态最终字符串KEY\u ADDR=“address”；
私有静态最终字符串密钥\u BTTLP=“瓶子价格”；
私有静态最终字符串键\u PBLNC=“prev\u balance”；
私有静态最终字符串键\u BLNC=“balance”；
私有静态最终字符串键\u BBTTLS=“bonif\u”；
私有静态最终字符串键\u PBTTLS=“prev\u”；
私有静态最终字符串密钥\u BTTLS=“瓶子”；
私有静态最终字符串键\u SYNC=“SYNC\u date”；
私有静态最终字符串键\u MODIF=“MODIF\u date”；
//移动表列
私有静态最终字符串MKEY_ROWID=“numint”；
私有静态最终字符串MKEY\u ID\u MOVE=“MOVE\u ID”；
私有静态最终字符串MKEY\u CLIENT\u ID=“CLIENT\u ID”；
专用静态最终字符串MKEY_PICKUP=“PICKUP”；
私有静态最终字符串MKEY_DELIVER=“DELIVER”；
私有静态最终字符串MKEY_PAYMENT=“PAYMENT”；
私有静态最终字符串MKEY\u MOVE\u DATE=“MOVE\u DATE”；
私有静态最终字符串MKEY\u SYNC\u DATE=“SYNC\u DATE”；
私有静态最终字符串MKEY\u FLAG\u SYNC=“FLAG\u SYNC”；
公共数据库处理程序（上下文）{
super（上下文、数据库名称、null、数据库版本）；
}
@凌驾
public void onCreate（SQLiteDatabase SQLiteDatabase）{
字符串CREATE_CLIENTS_TABLE=“CREATE TABLE”+CLIENTS_TABLE+”（“
+KEY_ROWID+“整型主键自动递增不为NULL，”
+KEY_NAME+“文本不为空，”
+密钥_LOCAL+“文本不为空，”
+KEY_ADDR+“文本不为空，”
+KEY_BTTLP+“实际值不为空”
+KEY_PBLNC+“实不为空”
+键\u BLNC+“实际值不为空，”
+KEY_BBTTLS+“整数不为空，”
+密钥\u PBTTLS+“整数不为空，”
+密钥\u BTTLS+“整数不为空，”
+键同步+“文本不为空，”
+键_MODIF+“文本不为空”；
字符串CREATE_MOVEMENTS_TABLE=“CREATE TABLE”+MOVEMENTS_TABLE+”（“
+MKEY_ROWID+“整数主键自动递增不为NULL，”
+MKEY_ID_MOVE+“文本不为空”
+MKEY_客户端ID+“整数不为空”
+MKEY_拾取+“整数不为空”
+MKEY_DELIVER+“整数不为空，”
+MKEY_付款+“不动产不为空，”
+MKEY_MOVE_DATE+“文本不为空，”
+MKEY_SYNC_DATE+“文本不为空”
+MKEY_标志_SYNC+“整数不为空”；
execSQL（创建客户机表）；
execSQL（创建表）；
}
@凌驾
public void onUpgrade（SQLiteDatabase SQLiteDatabase，int-oldVersion，int-newVersion）{
execSQL（“如果存在删除表”+客户机表）；
execSQL（“如果存在删除表”+移动表）；
onCreate（sqLiteDatabase）；
}
公共无效添加客户端（客户端）{
SQLiteDatabase db=this.getWritableDatabase（）；
ContentValues=新的ContentValues（）；
value.put（KEY_NAME，client.getName（））；
value.put（KEY_LOCAL，client.getLocality（））；
value.put（KEY_ADDR，client.getAddress（））；
value.put（KEY_BTTLP，client.getBottalPrice（））；
value.put（KEY_PBLNC，client.getPrevBalance（））；
value.put（KEY_BLNC，client.getBalance（））；
value.put（KEY_BBTTLS，client.getbonifflags（））；
value.put（KEY_PBTTLS，client.getPrevVa瓶（））；
value.put（KEY_BTTLS，client.getVa瓶（））；
value.put（KEY_SYNC，client.getSyncDate（））；
value.put（KEY_MODIF，client.getModifDate（））；
//插入行
db.insert（CLIENTS_TABLE，null，value）；
db.close（）；
}
公共客户端getClient（int-id）{
SQLiteDatabase db=this.getReadableDatabase（）；
Cursor Cursor=db.query（CLIENTS\u TABLE，新字符串[]{KEY\u ROWID，KEY\u NAME，KEY\u LOCAL，
密钥地址，密钥BTTLP，密钥PBLNC，密钥BLNC，密钥BBTTLS，密钥PBTTLS，密钥BTTLS，密钥同步，密钥MODIF}，密钥ROWID+“=？”，
新字符串[]{String.valueOf（id）}，null，null，null，null）；
如果（光标！=null）{
cursor.moveToFirst（）；
}
Client Client=new Client（Integer.parseInt（cursor.getString（0）），cursor.getString（1），cursor.getString（2），
cursor.getString（3）、Float.parseFloat（cursor.getString（4））、Float.parseFloat（cursor.getString（5）），
Float.parseFloat（cursor.getString（6）），Integer.parseInt（cursor.getString（7）），Integer.parseInt（cursor.getString（8）），
parseInt（cursor.getString（9））、cursor.getString（10）、cursor.getString（11））；
返回客户；
}
公共列表GetAllClient（）{
List clientList=new ArrayList（）；
String selectQuery=“SELECT*FROM”+客户\表；
SQLiteDat