Persistance Local com SQLite em Flutter: Um Guia Definitivo

Persistência Local com SQLite em Flutter

A persistência local é a capacidade de armazenar e recuperar dados no device do usuário. O SQLite é uma biblioteca de banco de dados embutida no Android, que permite criar e gerenciar bases de dados locais. Em Flutter, o SQLite pode ser usado para implementar persistência local em seus aplicativos.

* Visão leiga: a persistência local com SQLite é uma maneira de armazenar e recuperar dados em seu aplicativo de forma eficiente e segura.
* Explicação técnica: O SQLite fornece uma API segura para criar, manipular e recuperar registros de uma base de dados locais. O flutter usa um pacote chamado sqflite que faz a conexão entre o SQlite e a API Flutter do flutter.
* Por que isso importa hoje: A persistência local com SQLite é fundamental para os aplicativos móveis, pois permite que eles armazenem e recuperem dados locais sem a necessidade de uma conexão com um servidor.

ENTENDA A FUNÇÃO E A UTILIDADE DO TEMA

A persistência local com SQLite é especialmente útil em aplicativos móveis, como:

* Aplicativos de jogos
* Aplicativos de finanças pessoais
* Aplicativos de música ou vídeo

Exemplo de um aplicativo que pode usar persistência local com SQLite

import 'package:flutter/material.dart';
import 'package:sqflite/sqflite.dart';

class JogoDoTrabalho extends StatefulWidget {
  @override
  _JogoDoTrabalhoState createState() => _JogoDoTrabalhoState();
}

class _JogoDoTrabalhoState extends State<JogoDoTrabalho> {
  int pontuacao = 0;

  Future<void> começarJogo() async {
    final db = await abrirDatabase('trabalho.db');
    final row = Row(
      children: [
        Text('Pontuação: ${pontuacao}'),
        ElevatedButton(onPressed: () => aumentarPonte(), child: Text('Aumentar Pontuação'))
      ]
    );

    await db.insert(
      'Pontuacao',
      {
        'Pontuacao': pontuacao,
      },
    );
  }
}

void aumentarPontuaocao() async {
    final db = await abrirDatabase('trabalho.db');
    var row = await db.firstInsert;
    final Pontuacao resultRow =
        new Pontuacao(row[0]['Pontuacao']);
    print(resultRow.Pontuacao());
  }

Essa aplicação de jogos armazena a pontuação no banco local SQLite quando o usuário tocar um botão aumentar pontos, então é acessado em qualquer lugar do aplicativo. Existe muito mais com certeza.

GUIA COMPLETO E BEM ESTRUTURADO

* Como funciona

1. Instalar a biblioteca `sqflite`.

2. Criar uma base de dados e abrir um acesso a ela.

3. Criar ou recuperar os registros necessários.

4. Fechar o acesso da base de dados.
* Como aplicar:

1. Emprime um formulário com o código abaixo.

2. Alterne pelos resultados obtidos no passo 2

3. Armazene o código de retorno nos campos necessários, usando como chave o `id`, e armaze seus dados como se fossem tuplas simples na base de dados. Faça uma pesquisa em SQLite no site oficial sobre as tuplas.
* Como usar:

1. Abra a aplicação do Android

2. Execute as instruções.
* Como implementar:
-Instale a biblioteca SQlite no seu Flutter project

- Crie uma classe para encapsular o banco de dados. `SQLiteDB`

final sqflite.Database _database = await abrirDatabase('trabalho.db');
List<Trabalhos> get Trabalhose() {
    return _database
        .query('trabalho')
        .map((e) => Trabalhos.fromMap(e))
        .toList()
        ;
}

Future<void> gravarTrabalho(Trabalhos trabalhos, List<String> trabalhs) async {
  final sqflite.Database _database = await abrirDatabase('trabalho.db');
  return _database.insert('Trabalho', trabalhos.map((e) => e.trabalhos).toList()).then((_){} );
}

- Instala o pacote `sqflite` para flutter, instale usando a ferramenta o Package, com comando no terminal de comando

- Adiciona um atributo da propriedade do banco

import 'package:flutter/material.dart';
import 'package:sqflite/sqflite.dart';

class TrabalhoModel {
  String id;
  String nome;
  int pontuacao;

  TrabalhoModel({required this.id, required this.nome, required this.pontuacao});

  factory Trabalhos.fromMap(Map<String,dynamic> json) => TrabalhoModel(
    nome: json['nome'],
    pontuacao : json['pontucao']
      ,
    id : json['id']
   )
}

* Como resolver problemas

- Melhores práticas

- Use `future` para garantir que você execute todos os bancos com segurança. No código acima ele usou Future. Em outras palavras o code já resolve o problema, caso esteja sem segurança a classe do modelo não faria nada
- Passo a passo realista: A ideia é que um sistema, no momento de abrir o aplicativo armazene as suas coisas.

- Exemplos Reais

É exemplo simples com alguns bancos

class App extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'SQLite Demo',
      home: Scaffold(
        appBar: AppBar(
          title: Text('SQLite Demo'),
        ),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              ElevatedButton(
                onPressed: () async {
                  final db = await openDatabase("path/to/databases/mydb.db",
                      onCreate: (db, version) async {
                        return 'my db'; // create a database with one table
                      },
                      onUpgrade: (db, oldVersion, newVersion) {
                        if(oldVersion < 1)
                          return;
                        db.execute(
                            "CREATE TABLE IF NOT EXISTS my_table(id INTEGER PRIMARY KEY, data TEXT)"
                            );
                      });

                  final rows = await db.query('my_table');
                ButtonStyle(onPressed: MaterialButtonProps.onPressed, elevationColor : Colors.green),
                  child: Text('Abra a base de dados'))
              ),
            ],
          ),
        ),
      ),
    );
  }
}

Comparação
A persistência local com SQLite é uma solução popular para armazenar e recuperar dados em aplicativos móveis. Outras alternativas incluem:

* Arquitetura cliente-servidor * Caching * API REST

Essas tecnologias têm suas vantagens e desvantagens, e a escolha da persistência local com SQLite depende do requisito específico do projeto.

Tendências Futuras

A tendência é utilizar o flutter SQlite como um sistema de armazenamento locais.

E é claro um bom conceito desenvolver algum tutorial com tutoriais práticos para tornar algo a ser realmente fácil e acessível ao seu público, mas é um tópico muito amplo então não foi possível fornecer algo tão extensivo que é capaz de satisfazer uma resposta total, isso já pode dar lugar a mais alguma ação de investigação sobre como implementar a tecnologia em seus casos ou se necessário criar mais conteúdo no tema persistência local com SQLite para se manter atualizado sobre o desenvolvimento de tal técnica e seus padrões.


Aprenda a criar aplicativos móveis com persistência local eficiente e escalável usando SQLite e Flutter. Descubra como armazenar e recuperar dados de forma segura e rápida.
Referências: persistência local, SQLite, Flutter, aplicativos móveis, armazenamento de dados, caixa de dados,

Flutter

Flutter é um framework UI multiplataforma do Google que permite criar aplicativos nativos para Android, iOS, Web e Desktop usando uma única base de código em Dart, oferecendo alto desempenho, widgets personalizáveis e uma experiência de desenvolvimento produtiva.