Mobilutvikling med Flutter · leksjon

Integrering av SQLite-database

Integrer SQLite-databaser i Flutter-appen ved hjelp av `sqflite`-pakken for strukturert og relasjonell datalagring.

Leksjon 2 av 412 trinn

Integrering av SQLite-database er en gratis leksjon i Mobilutvikling med Flutter på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Mobilutvikling med Flutter, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Mobilutvikling med Flutter inneholder totalt 4 leksjoner.

Lagre data med SQLite

Velkommen! I denne leksjonen lærer du hvordan du integrerer en lokal database i Flutter-appen din ved hjelp av SQLite.

SQLite er en lettvekts, serverløs, selvstendig og transaksjonsbasert relasjonsdatabasemotor. Den egner seg perfekt til å lagre strukturerte data direkte på brukerens enhet uten behov for en separat serverprosess.

Klargjøre `sqflite`

For å bruke SQLite i Flutter benytter vi den populære pakken sqflite. Den tilbyr et robust grensesnitt mot SQLite-databaser.

Legg den først til (sammen med path_provider og path for håndtering av databasefiler) i filen pubspec.yaml under dependencies:

dependencies:
flutter:
sdk: flutter
sqflite: ^2.3.0
path_provider: ^2.1.1
path: ^1.8.3

Kjør flutter pub get i terminalen etter at du har lagt til disse.

Databasehjelperklasse

Det er god praksis å opprette en dedikert «hjelperklasse» for å håndtere databaseoperasjonene. Da samler du logikken for åpning, oppretting og kjøring av spørringer på ett sted.

Denne klassen håndterer vanligvis:

Initialisering og åpning av databasetilkoblingen.
Oppretting av tabeller første gang databasen åpnes.
Tilgjengeliggjøring av én enkelt instans (singleton) av databasen for hele applikasjonen.
Abstrahering av direkte SQL-spørringer.

Initialisere databasen

La oss begynne å bygge DatabaseHelper. Funksjonen openDatabase er sentral. Den tar filbanen til databasen og en onCreate-tilbakekalling for det innledende oppsettet.

Slik åpner eller oppretter du databasen:

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// NOTE: getDatabasesPath() requires Flutter context.
// This main method is for demonstration.
// In a real Flutter app, _initDatabase would be called
// from a StatefulWidget or similar.

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;

  factory DatabaseHelper() {
    return _instance;
  }

  DatabaseHelper._internal();

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

  Future<Database> _initDatabase() async {
    // Get the default databases location for the platform
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');

    return await openDatabase(
      dbPath,
      version: 1,
      onCreate: (db, version) {
        // Table creation logic will go here
        print('Database created or opened.');
      },
    );
  }
}

void main() async {
  // This main is illustrative. sqflite operations need a
  // running Flutter app context to fully function (e.g. for getDatabasesPath).
  // When run in a Flutter app, DatabaseHelper().database
  // would ensure the DB is initialized.
  print('DatabaseHelper class defined.');
}

Opprette den første tabellen

Inne i onCreate-tilbakekallingen til _initDatabase definerer vi databaseskjemaet ved hjelp av standard SQL. La oss opprette en enkel items-tabell.

Hvert element får en id (primærnøkkel), et name (tekst) og en quantity (heltall).

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        // SQL to create the items table
        await db.execute(
          '''
          CREATE TABLE items(
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT,
            quantity INTEGER
          )
          '''
        );
        print('Table "items" created successfully.');
      },
    );
  }
}

void main() async {
  // This main is illustrative. In a Flutter app,
  // calling DatabaseHelper().database would trigger
  // _initDatabase and the onCreate callback.
  print('Database helper configured for table creation.');
}

Opprette en datamodell

For å kunne arbeide enkelt med databaseposter definerer du en Dart-klasse som gjenspeiler strukturen i tabellen. Dette gjør det enklere å mappe data mellom Dart-objekter og databaserekker (som vanligvis representeres som Map).

Her er Item-modellen vår med metodene toMap() og fromMap():

class Item {
  final int? id;
  final String name;
  final int quantity;

  Item({this.id, required this.name, required this.quantity});

  // Convert an Item into a Map. Keys must match DB column names.
  Map<String, dynamic> toMap() {
    return {
      'id': id,
      'name': name,
      'quantity': quantity,
    };
  }

  // Create an Item object from a Map (database row).
  static Item fromMap(Map<String, dynamic> map) {
    return Item(
      id: map['id'],
      name: map['name'],
      quantity: map['quantity'],
    );
  }

  @override
  String toString() {
    return 'Item(id: $id, name: $name, quantity: $quantity)';
  }
}

void main() {
  final myItem = Item(id: 1, name: 'Apple', quantity: 5);
  print('Created Item: ${myItem.toString()}');
  print('Converted to Map: ${myItem.toMap()}');

  final itemMap = {'id': 2, 'name': 'Banana', 'quantity': 3};
  final itemFromMap = Item.fromMap(itemMap);
  print('Item from Map: ${itemFromMap.toString()}');
}

Sette inn data

La oss nå legge til en metode i DatabaseHelper for å sette inn nye elementer. Metoden insert tar tabellnavnet og en Map (fra Item.toMap()).

Den returnerer id-en til den nylig innsatte raden.

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// Item class (from previous scene, for self-containment)
class Item {
  final int? id; final String name; final int quantity;
  Item({this.id, required this.name, required this.quantity});
  Map<String, dynamic> toMap() { return {'id': id, 'name': name, 'quantity': quantity}; }
  static Item fromMap(Map<String, dynamic> map) { return Item(id: map['id'], name: map['name'], quantity: map['quantity']); }
  @override
  String toString() { return 'Item(id: $id, name: $name, quantity: $quantity)'; }
}

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE items(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, quantity INTEGER)
          ''');
      },
    );
  }

  Future<int> insertItem(Item item) async {
    final db = await database;
    return await db.insert(
      'items',
      item.toMap(),
      conflictAlgorithm: ConflictAlgorithm.replace, // Replace if ID exists
    );
  }
}

void main() async {
  // Illustrative main. In a Flutter app, you'd call:
  // final dbHelper = DatabaseHelper();
  // final newItem = Item(name: 'Milk', quantity: 2);
  // int id = await dbHelper.insertItem(newItem);
  // print('Inserted item with id: $id');
  print('Item insertion logic defined in DatabaseHelper.');
}

Spørre etter data

For å lese data bruker du metoden query. Den returnerer en List>, som du deretter konverterer tilbake til Dart-objekter av typen Item ved hjelp av Item.fromMap().

Du kan spørre etter alle elementer eller bestemte elementer ved hjelp av where-betingelser.

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// Item class (for self-containment)
class Item {
  final int? id; final String name; final int quantity;
  Item({this.id, required this.name, required this.quantity});
  Map<String, dynamic> toMap() { return {'id': id, 'name': name, 'quantity': quantity}; }
  static Item fromMap(Map<String, dynamic> map) { return Item(id: map['id'], name: map['name'], quantity: map['quantity']); }
  @override
  String toString() { return 'Item(id: $id, name: $name, quantity: $quantity)'; }
}

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE items(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, quantity INTEGER)
          ''');
      },
    );
  }

  Future<List<Item>> getItems() async {
    final db = await database;
    // Query all the items from the table
    final List<Map<String, dynamic>> maps = await db.query('items');

    // Convert the List<Map<String, dynamic>> into a List<Item>.
    return List.generate(maps.length, (i) {
      return Item.fromMap(maps[i]);
    });
  }
}

void main() async {
  // Illustrative main. In a Flutter app, you'd call:
  // final dbHelper = DatabaseHelper();
  // await dbHelper.insertItem(Item(name: 'Bread', quantity: 1));
  // final items = await dbHelper.getItems();
  // print('Retrieved items: $items');
  print('Item query logic defined in DatabaseHelper.');
}

Oppdatere data

For å endre en eksisterende post bruker du metoden update. Du oppgir tabellnavnet, de nye dataene som en Map og en where-betingelse som angir hvilke poster som skal oppdateres.

Bruk alltid whereArgs sammen med plassholdere (?) for å sende verdier på en sikker måte og forhindre SQL-injeksjon.

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// Item class (for self-containment)
class Item {
  final int? id; final String name; final int quantity;
  Item({this.id, required this.name, required this.quantity});
  Map<String, dynamic> toMap() { return {'id': id, 'name': name, 'quantity': quantity}; }
  static Item fromMap(Map<String, dynamic> map) { return Item(id: map['id'], name: map['name'], quantity: map['quantity']); }
  @override
  String toString() { return 'Item(id: $id, name: $name, quantity: $quantity)'; }
}

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE items(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, quantity INTEGER)
          ''');
      },
    );
  }

  Future<int> updateItem(Item item) async {
    final db = await database;
    return await db.update(
      'items',
      item.toMap(),
      where: 'id = ?', // Specify which item to update
      whereArgs: [item.id],
    );
  }
}

void main() async {
  // Illustrative main. In a Flutter app, you'd call:
  // final dbHelper = DatabaseHelper();
  // // Assume item with id 1 exists
  // var updatedItem = Item(id: 1, name: 'Milk', quantity: 3);
  // int count = await dbHelper.updateItem(updatedItem);
  // print('Updated $count item(s).');
  print('Item update logic defined in DatabaseHelper.');
}

Slette data

For å fjerne poster fra databasen bruker du metoden delete. På samme måte som med update oppgir du tabellnavnet og en where-betingelse med whereArgs for å angi hvilke poster som skal fjernes.

Denne metoden returnerer antallet slettede rader.

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

// Item class (for self-containment)
class Item {
  final int? id; final String name; final int quantity;
  Item({this.id, required this.name, required this.quantity});
  Map<String, dynamic> toMap() { return {'id': id, 'name': name, 'quantity': quantity}; }
  static Item fromMap(Map<String, dynamic> map) { return Item(id: map['id'], name: map['name'], quantity: map['quantity']); }
  @override
  String toString() { return 'Item(id: $id, name: $name, quantity: $quantity)'; }
}

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;
  factory DatabaseHelper() { return _instance; }
  DatabaseHelper._internal();
  Future<Database> get database async { if (_database != null) return _database!; _database = await _initDatabase(); return _database!; }
  Future<Database> _initDatabase() async {
    String path = await getDatabasesPath();
    String dbPath = join(path, 'item_database.db');
    return await openDatabase(dbPath, version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE items(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, quantity INTEGER)
          ''');
      },
    );
  }

  Future<int> deleteItem(int id) async {
    final db = await database;
    return await db.delete(
      'items',
      where: 'id = ?',
      whereArgs: [id],
    );
  }
}

void main() async {
  // Illustrative main. In a Flutter app, you'd call:
  // final dbHelper = DatabaseHelper();
  // // Assume item with id 1 exists
  // int count = await dbHelper.deleteItem(1);
  // print('Deleted $count item(s).');
  print('Item deletion logic defined in DatabaseHelper.');
}

Quiz om SQLite-operasjoner

Se for deg en items-tabell med kolonnene id (INTEGER), name (TEXT) og quantity (INTEGER).

Hvilken sqflite-metode vil du bruke for å hente alle elementer der antallet er større enn 10?

Besvar den i den interaktive leksjonen

Oppsummering: SQLite og `sqflite`

Godt jobbet! Du har lært det grunnleggende om å integrere SQLite i Flutter-appen din ved hjelp av pakken sqflite.

Viktige punkter:

SQLite er en lettvekts, lokal relasjonsdatabase.
Pakken sqflite tilbyr Dart-API-er for SQLite.
En DatabaseHelper-klasse samler databaseoperasjoner som oppretting, åpning og håndtering av tabeller.
Du kan utføre standard CRUD-operasjoner (Create, Read, Update, Delete) ved hjelp av metodene insert, query, update og delete.
En datamodellklasse (som Item) gjør det enklere å mappe data mellom Dart-objekter og databaserekker.

Dette er viktig kunnskap når du skal bygge robuste Flutter-apper med lokal datalagring!

Gratis å komme i gang

Lær deg Dart med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 22
Leksjoner: 88

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Integrering av SQLite-database» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Mobilutvikling med Flutter, inkludert «Integrering av SQLite-database», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Mobilutvikling med Flutter inneholder totalt 4 leksjoner.

Hva lærer jeg i «Integrering av SQLite-database»?

Integrer SQLite-databaser i Flutter-appen ved hjelp av `sqflite`-pakken for strukturert og relasjonell datalagring. Du øver på Mobilutvikling med Flutter med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Mobilutvikling med Flutter?

Ingen tidligere erfaring er nødvendig. Mobilutvikling med Flutter på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Integrering av SQLite-database»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Mobilutvikling med Flutter-leksjonen?

Ja. Alle Mobilutvikling med Flutter-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Mobilutvikling med Flutter