如何在 flutter 中的 sqflite 数据库中读写

Question

Good day everyone,

I am developing an App usaing Flutter. To save some data localy I am using the SQFlite plugin.

I have a database helper class. I am using Provider to call my database methods.

When I call the method to write an account in the database I receive an autoincremented ID as response the the sucess of the insertion of the account.

The problem is when I call the method to read these accounts from the database I receiceive nothing. The response Map is null like I have nothing in the database.

If when I insert an account to my database I receive an ID as response, why when I try to read these account I receive nothing.

Please help, me. I am going insane with this code.

class DBProvider {
  static const String TABLE_ACCOUNTS = 'Accounts';
  static const String COLUMN_ID = 'accountID';
  static const String COLUMN_LOCAL_ID = 'id';
  static const String COLUMN_CUSTOMER_PICTURE = 'customerPictureBase64';
  static const String COLUMN_DOC_FRONT = 'docFrontPictureBase64';
  static const String COLUMN_DOC_BACK = 'docBackPictureBase64';
  static const String COLUMN_SIGNATURE = 'signatureBase64';
  static const String COLUMN_GENDER = 'gender';
  static const String COLUMN_FIRST_NAME = 'firstName';
  static const String COLUMN_LAST_NAME = 'lastName';
  static const String COLUMN_DOC_TYPE = 'docType';

  DBProvider._();
  static final DBProvider db = DBProvider._();
  Database _database;

  Future<Database> get database async {
    if (_database != null) {
      return _database;
    }
    _database = await createDatabase();
    return _database;
  }

  Future<Database> createDatabase() async {
    String dbPath = await getDatabasesPath();
    return await openDatabase(
      join(dbPath, 'paperless.db'),
      version: 1,
      onCreate: (Database database, int version) async {
        await database.execute(
          'CREATE TABLE $TABLE_ACCOUNTS ($COLUMN_LOCAL_ID INTEGER PRIMARY KEY, $COLUMN_ID TEXT, '
          '$COLUMN_CUSTOMER_PICTURE TEXT, $COLUMN_DOC_FRONT TEXT, '
          '$COLUMN_DOC_BACK TEXT, $COLUMN_SIGNATURE TEXT, '
          '$COLUMN_GENDER INTEGER, $COLUMN_FIRST_NAME TEXT, '
          '$COLUMN_LAST_NAME TEXT, $COLUMN_DOC_TYPE TEXT)',
        );
      },
    );
  }

  Future<List<LowKYCAccount>> getLocalLowKYCAccount() async {
    final db = await database;

    var accounts = await db.rawQuery('SELECT * FROM $TABLE_ACCOUNTS');

    var accountsList = List<LowKYCAccount>();

    accounts.forEach((account) {
      LowKYCAccount kycAccount = LowKYCAccount.fromMap(account);
      accountsList.add(kycAccount);
    });
    return accountsList;
  }

  Future<LowKYCAccount> saveAccountLocaly(LowKYCAccount account) async {
    final db = await database;
    account.localId = await db.insert(TABLE_ACCOUNTS, account.toMap());
    return account;
  }
}

I am calling this methods from my UI sing provider

class LowKYCProvider with ChangeNotifier {
  LowKYCAccount _selectedAccount;
  List<LowKYCAccount> _lowKycAccounts = [];
  List<LowKYCAccount> _localLowKycAccounts = [];

  LowKYCAccount get selectedAccount {
    return _selectedAccount;
  }

  List<LowKYCAccount> get lowKycAccounts {
    return [..._lowKycAccounts];
  }

  List<LowKYCAccount> get localLowKycAccounts {
    return [..._localLowKycAccounts];
  }

  Future<void> submitNewAccount(LowKYCAccount account) async {}

  Future<void> fetchLowKycAccounts() async {
    if (_lowKycAccounts.isEmpty) {
      notifyListeners();
    }
  }

  Future<void> fetchLocalLowKycAccounts() async {
    print('vamos fetchar os locais');
    await DBProvider.db.getLocalLowKYCAccount().then((accounts) {
      _localLowKycAccounts = accounts;
      //notifyListeners();
    });
    print('Já terminamos');
  }

  Future<void> saveAccountLocaly(LowKYCAccount account) async {
    await DBProvider.db
        .saveAccountLocaly(account)
        .then((account) => _localLowKycAccounts.add(account));
    notifyListeners();
  }

  Future<void> updateLowKycAccount(LowKYCAccount account) async {}

  Future<void> setSelectedAccount(int index) async {
    _selectedAccount = _lowKycAccounts[index];
    notifyListeners();
  }
}

this is the model class

class LowKYCAccount {
  String id;
  int localId;
  String customerPictureBase64;
  String docFrontPictureBase64;
  String docBackPictureBase64;
  int gender;
  String firstName;
  String lastName;
  String docType;

  File signatureFile;
  String signatureUrl;

  LowKYCAccount({
    this.id,
    this.localId,
    this.customerPictureBase64,
    this.docFrontPictureBase64,
    this.docBackPictureBase64,
    this.gender,
    this.firstName,
    this.lastName,
    this.docType,
    this.signatureUrl,
    this.signatureFile,
  });

  Map<String, dynamic> toMap() {
    var map = <String, dynamic>{
      DBProvider.COLUMN_ID: id,
      DBProvider.COLUMN_CUSTOMER_PICTURE: customerPictureBase64,
      DBProvider.COLUMN_DOC_FRONT: docFrontPictureBase64,
      DBProvider.COLUMN_DOC_BACK: docBackPictureBase64,
      DBProvider.COLUMN_GENDER: gender,
      DBProvider.COLUMN_FIRST_NAME: firstName,
      DBProvider.COLUMN_LAST_NAME: lastName,
      DBProvider.COLUMN_DOC_TYPE: docType,
    };

    if (localId != null) {
      map[DBProvider.COLUMN_LOCAL_ID] = localId;
    }
    return map;
  }

  LowKYCAccount.fromMap(Map<String, dynamic> account) {
    id = account[DBProvider.COLUMN_ID];
    localId = account[DBProvider.COLUMN_LOCAL_ID];
    customerPictureBase64 = account[DBProvider.COLUMN_CUSTOMER_PICTURE];
    docFrontPictureBase64 = account[DBProvider.COLUMN_DOC_FRONT];
    docBackPictureBase64 = account[DBProvider.COLUMN_DOC_BACK];
    gender = account[DBProvider.COLUMN_GENDER];
    firstName = account[DBProvider.COLUMN_FIRST_NAME];
    lastName = account[DBProvider.COLUMN_LAST_NAME];
    docType = account[DBProvider.COLUMN_DOC_TYPE];
  }
}

Answer 1

No experience with this type of plugin or this database, but you should probably use transactions: Otherwise your data will probably not be committed:

await database.transaction((txn) async {
  var batch = txn.batch();

  // ... insert your data here!

  // commit but the actual commit will happen when the transaction is committed
  // however the data is available in this transaction
  await batch.commit();

  //  ...
});

and the insert example:

// Insert some records in a transaction
await database.transaction((txn) async {
  int id1 = await txn.rawInsert(
      'INSERT INTO Test(name, value, num) VALUES("some name", 1234, 456.789)');
  print('inserted1: $id1');
  int id2 = await txn.rawInsert(
      'INSERT INTO Test(name, value, num) VALUES(?, ?, ?)',
      ['another name', 12345678, 3.1416]);
  print('inserted2: $id2');
});

See https://pub.dev/packages/sqflite for more info on transactions