Usando SQLite.NET com Android

A biblioteca de SQLite.NET que o Xamarin recomenda é um ORM muito básico que permite armazenar e recuperar facilmente objetos no banco de dados SQLite local em um dispositivo Android. ORM significa Mapeamento Relacional de Objeto – uma API que permite salvar e recuperar "objetos" de um banco de dados sem gravar instruções SQL.

Para incluir a biblioteca SQLite.NET em um aplicativo Xamarin, adicione o seguinte pacote NuGet ao seu projeto:

• Nome do Pacote: sqlite-net-pcl
• Autor: Frank A. Krueger
• Id: sqlite-net-pcl
• Url:nuget.org/packages/sqlite-net-pcl

Há vários pacotes SQLite diferentes disponíveis– certifique-se de escolher o correto (pode não ser o principal resultado na pesquisa).

Importante

SQLite.NET é uma biblioteca de terceiros com suporte do repositório praeclarum/sqlite-net.

Depois de ter a biblioteca SQLite.NET disponível, siga estas três etapas para usá-la para acessar um banco de dados:

1. Adicionar uma instrução using – adicione a seguinte instrução aos arquivos C# em que o acesso a dados é necessário:

   using SQLite;
   

2. Criar um Banco de Dados em Branco – uma referência de banco de dados pode ser criada passando o caminho do arquivo para o construtor da classe SQLiteConnection. Você não precisará marcar se o arquivo já existir – ele será criado automaticamente, se necessário, caso contrário, o arquivo de banco de dados existente será aberto. A dbPath variável deve ser determinada de acordo com as regras discutidas anteriormente neste documento:

   var db = new SQLiteConnection (dbPath);
   

3. Salvar Dados – depois de criar um objeto SQLiteConnection, os comandos de banco de dados são executados chamando seus métodos, como CreateTable e Insert desta forma:

   db.CreateTable<Stock> ();
   db.Insert (newStock); // after creating the newStock object
   

4. Recuperar Dados – para recuperar um objeto (ou uma lista de objetos) use a seguinte sintaxe:

   var stock = db.Get<Stock>(5); // primary key id of 5
   var stockList = db.Table<Stock>();
   

Exemplo básico de acesso a dados

O DataAccess_Basic código de exemplo para este documento tem esta aparência ao ser executado no Android. O código ilustra como executar operações de SQLite.NET simples e mostra os resultados como texto na janela main do aplicativo.

Android

O exemplo de código a seguir mostra toda uma interação de banco de dados usando a biblioteca SQLite.NET para encapsular o acesso ao banco de dados subjacente. Ele mostra:

1. Criando o arquivo de banco de dados

2. Inserindo alguns dados criando objetos e salvando-os

3. Consulta dos dados

Você precisará incluir esses namespaces:

using SQLite; // from the github SQLite.cs class

O último requer que você tenha adicionado o SQLite ao seu projeto. Observe que a tabela de banco de dados SQLite é definida adicionando atributos a uma classe (a Stock classe) em vez de um comando CREATE TABLE.

[Table("Items")]
public class Stock {
    [PrimaryKey, AutoIncrement, Column("_id")]
    public int Id { get; set; }
    [MaxLength(8)]
    public string Symbol { get; set; }
}
public static void DoSomeDataAccess () {
       Console.WriteLine ("Creating database, if it doesn't already exist");
   string dbPath = Path.Combine (
        Environment.GetFolderPath (Environment.SpecialFolder.Personal),
        "ormdemo.db3");
   var db = new SQLiteConnection (dbPath);
   db.CreateTable<Stock> ();
   if (db.Table<Stock> ().Count() == 0) {
        // only insert the data if it doesn't already exist
        var newStock = new Stock ();
        newStock.Symbol = "AAPL";
        db.Insert (newStock);
        newStock = new Stock ();
        newStock.Symbol = "GOOG";
        db.Insert (newStock);
        newStock = new Stock ();
        newStock.Symbol = "MSFT";
        db.Insert (newStock);
    }
    Console.WriteLine("Reading data");
    var table = db.Table<Stock> ();
    foreach (var s in table) {
        Console.WriteLine (s.Id + " " + s.Symbol);
    }
}

Usar o [Table] atributo sem especificar um parâmetro de nome de tabela fará com que a tabela de banco de dados subjacente tenha o mesmo nome que a classe (nesse caso, "Stock"). O nome da tabela real será importante se você gravar consultas SQL diretamente no banco de dados em vez de usar os métodos de acesso a dados ORM. Da mesma forma, o [Column("_id")] atributo é opcional e, se não houver uma coluna, será adicionado à tabela com o mesmo nome que a propriedade na classe .

Atributos SQLite

Os atributos comuns que você pode aplicar às suas classes para controlar como elas são armazenadas no banco de dados subjacente incluem:

• [PrimaryKey] – Esse atributo pode ser aplicado a uma propriedade de inteiro para forçá-lo a ser a chave primária da tabela subjacente. Não há suporte para chaves primárias compostas.

• [AutoIncrement] – Esse atributo fará com que o valor de uma propriedade de inteiro seja incremento automático para cada novo objeto inserido no banco de dados

• [Column(name)] – O name parâmetro define o nome da coluna de banco de dados subjacente.

• [Table(name)] – marca a classe como sendo capaz de ser armazenada em uma tabela SQLite subjacente com o nome especificado.

• [MaxLength(value)] – Restrinja o comprimento de uma propriedade de texto quando uma inserção de banco de dados for tentada. O consumo de código deve validar isso antes de inserir o objeto, pois esse atributo só é "verificado" quando uma operação de inserção ou atualização de banco de dados é tentada.

• [Ignorar] – faz com que SQLite.NET ignorem essa propriedade. Isso é particularmente útil para propriedades que têm um tipo que não pode ser armazenado no banco de dados ou propriedades que modelam coleções que não podem ser resolvidas automaticamente pelo SQLite.

• [Exclusivo] – Garante que os valores na coluna de banco de dados subjacente sejam exclusivos.

A maioria desses atributos são opcionais. Você sempre deve especificar uma chave primária de inteiro para que as consultas de seleção e exclusão possam ser executadas com eficiência em seus dados.

Consultas mais complexas

Os seguintes métodos em SQLiteConnection podem ser usados para executar outras operações de dados:

• Inserir – adiciona um novo objeto ao banco de dados.

• Obter<T> – tenta recuperar um objeto usando a chave primária.

• Tabela<T> – retorna todos os objetos na tabela.

• Excluir – exclui um objeto usando sua chave primária.

• Consulta<T> – Execute uma consulta SQL que retorna várias linhas (como objetos).

• Execute – use esse método (e não Query) quando não esperar linhas de volta do SQL (como instruções INSERT, UPDATE e DELETE).

Obtendo um objeto pela chave primária

SQLite.Net fornece o método Get para recuperar um único objeto com base em sua chave primária.

var existingItem = db.Get<Stock>(3);

Selecionando um objeto usando Linq

Métodos que retornam suporte IEnumerable<T> a coleções para que você possa usar o Linq para consultar ou classificar o conteúdo de uma tabela. O código a seguir mostra um exemplo usando Linq para filtrar todas as entradas que começam com a letra "A":

var apple = from s in db.Table<Stock>()
    where s.Symbol.StartsWith ("A")
    select s;
Console.WriteLine ("-> " + apple.FirstOrDefault ().Symbol);

Selecionando um objeto usando SQL

Embora SQLite.Net possa fornecer acesso baseado em objeto aos seus dados, às vezes talvez seja necessário fazer uma consulta mais complexa do que o Linq permite (ou talvez você precise de um desempenho mais rápido). Você pode usar comandos SQL com o método Query, conforme mostrado aqui:

var stocksStartingWithA = db.Query<Stock>("SELECT * FROM Items WHERE Symbol = ?", "A");
foreach (var s in stocksStartingWithA) {
    Console.WriteLine ("a " + s.Symbol);
}

Observação

Ao escrever instruções SQL diretamente, você cria uma dependência nos nomes de tabelas e colunas em seu banco de dados, que foram gerados a partir de suas classes e seus atributos. Se você alterar esses nomes em seu código, lembre-se de atualizar todas as instruções SQL gravadas manualmente.

Excluindo um objeto

A chave primária é usada para excluir a linha, conforme mostrado aqui:

var rowcount = db.Delete<Stock>(someStock.Id); // Id is the primary key

Você pode marcar o rowcount para confirmar quantas linhas foram afetadas (excluídas nesse caso).

Usando SQLite.NET com vários threads

O SQLite dá suporte a três modos de thread diferentes: Thread único, Multi-thread e Serializado. Se você quiser acessar o banco de dados de vários threads sem nenhuma restrição, poderá configurar o SQLite para usar o modo de threading serializado . É importante definir esse modo no início do aplicativo (por exemplo, no início do OnCreate método).

Para alterar o modo de threading, chame SqliteConnection.SetConfig. Por exemplo, essa linha de código configura o SQLite para o modo Serializado :

using using Mono.Data.Sqlite;
...
SqliteConnection.SetConfig(SQLiteConfig.Serialized);

A versão android do SQLite tem uma limitação que requer mais algumas etapas. Se a chamada para SqliteConnection.SetConfig produzir uma exceção SQLite como library used incorrectly, você deverá usar a seguinte solução alternativa:

1. Vincule-se à biblioteca de libsqlite.so nativa para que as sqlite3_shutdown APIs e sqlite3_initialize sejam disponibilizadas para o aplicativo:

   [DllImport("libsqlite.so")]
   internal static extern int sqlite3_shutdown();
   
   [DllImport("libsqlite.so")]
   internal static extern int sqlite3_initialize();
   

2. No início do OnCreate método, adicione esse código para desligar o SQLite, configurá-lo para o modo Serializado e reinicializar o SQLite:

   using using Mono.Data.Sqlite;
   ...
   sqlite3_shutdown();
   SqliteConnection.SetConfig(SQLiteConfig.Serialized);
   sqlite3_initialize();
   

Essa solução alternativa também funciona para a Mono.Data.Sqlite biblioteca. Para obter mais informações sobre SQLite e vários threadings, consulte SQLite e Vários Threads.

Links Relacionados

• DataAccess Basic (exemplo)
• DataAccess Advanced (exemplo)
• Acesso a dados do Xamarin.Forms