Your Web News in One Place

Help Webnuz

Referal links:

Sign up for GreenGeeks web hosting
September 27, 2021 12:33 am GMT

Usando a Biblioteca Exposed

Kotlinautas

Esse contedo oferecido e distribudo pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer contedo gratuito sobre a linguagem Kotlin em um espao plural.

capa Kotlinautas

O qu um ORM?

ORM (Mapeamento de Objeto Relacional) uma maneira de mapear dados de um banco de dados, em objetos de uma aplicao. Como se fosse uma ponte entre classes da nossa aplicao, e o banco de dados da aplicao.

ORM's servem principalmente para facilitar a comunicao entre uma aplicao e seu banco de dados. Facilitando processos de leitura, escrita, atualizao e remoo de dados.

O qu Exposed?

Exposed a biblioteca oficial de ORM para Kotlin, criada pela prpria JetBrains. Uma de suas principais vantagens poder usar diferentes bancos de dados, e poder trocar qual banco voc est usando de maneira fcil. A lista de bancos de dados atualmente suportada pelo Exposed :

  • H2
  • MySQL
  • MariaDB
  • Oracle
  • PostgreSQL
  • SQL Server
  • SQLite

O qu vamos criar?

Vamos criar um sistema de cadastro de planetas. Onde poderemos inserir informaes sobre um planeta, e essas informaes sero inseridas em um banco de dados. Com isso, poderemos usar a Exposed para conectar a nossa aplicao, um banco de dados que desejarmos.

Criando o projeto

Abra seu IntelliJ no menu inicial e clique em New Project:

boto New Project no menu inicial do IntelliJ

Depois, selecione a opo Kotlin DSL build script, selecione tambm a opo Kotlin/JVM, e opicionalmente remova a primeira opo Java. Essa opo no vai mudar em nada, pois ela d suporte do Gradle linguagem Java, mas apenas iremos usar Kotlin.

Aps isso, clique em Next e escreva o nome do projeto e a localizao na sua mquina. Essas duas opo so completamente pessoais, caso no tenha nenhuma ideia, coloque algo como exposed apenas como identificao.

Agora, com o projeto aberto, v ao aquivo build.gradle.kts e adicione as dependncias da Exposed, com a seo dependencies ficando assim:

dependencies {    implementation(kotlin("stdlib"))    implementation("org.jetbrains.exposed:exposed-core:0.33.1")    implementation("org.jetbrains.exposed:exposed-dao:0.33.1")    implementation("org.jetbrains.exposed:exposed-jdbc:0.33.1")    implementation("com.h2database:h2:1.4.199")    implementation("org.slf4j:slf4j-api:1.7.5")    implementation("org.slf4j:slf4j-simple:1.6.4")}

Agora, clique no elefante no canto superior direito para carregar as alteraes no Gradle.

Elefante do Gradle no canto superior direito

Aps isso, poderemos comear a programar. Voc pode criar um arquivo em src/main/kotlin/ chamado main.kt para ser o arquivo principal da aplicao.

Mas com qualquer nome de arquivo, como voc ir usar a Exposed, sempre se lembre de importar a Exposed no comeo do arquivo:

import org.jetbrains.exposed.sql.*

Usando a Exposed

Primeiro, vamos precisar criar um objeto que ir representar uma tabela em nosso banco de dados, e dentro desse objeto inserir as colunas do nosso banco (como propriedades). Isso pode ser feito da seguinte maneira:

import org.jetbrains.exposed.sql.*import org.jetbrains.exposed.sql.transactions.transactionobject Planetas: Table(){    val nome = varchar("nome", 30)    val massa = double("massa")    val solido = bool("solido")}
  • Usamos a palavra object para criar o objeto, colocamos o nome da tabela Planetas, e o tipo da varivel, que um tipo da Exposed, Sendo Table;
  • Dentro do objeto, criamos trs variveis, sendo nome, massa, e solido. nome ir guardar o nome do planeta, massa ir guardar a massa do planeta comparada terra e solido ir determinar se o planeta slido ou no;
  • Para determinar essas variveis, usamos tipos de dados de um banco de dados, como varchar, double, e bool;

Aps isso, podemos criar a nossa funo main. Dentro dela, vamos primeiramente conectar ao banco de dados. Isso pode ser feito com a funo Database.connect dessa maneira:

...fun main(){    Database.connect("jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;", "org.h2.Driver")}
  • Estamos usando o banco de dados H2. Um banco de dados Java, que pode funcionar apenas na memria. Vamos usar esse banco de dados pois a cada vez que rodarmos o programa, teremos um novo banco totalmente zerado. Com isso voc ficar livre para testar o banco, criando, lendo, editando e removendo dados;
  • Para fazer essa conexo, tivemos que passar um texto que representa esse banco. Caso voc queira mudar o banco, voc apenas ir precisar mudar esse texto;

Agora precisamos inserir a tabela Planetas que criamos no banco. Isso pode ser feito de maneira completamente automtica usando a funo SchemaUtils.create. Essa funo pode ser usada da seguinte maneira:

...fun main(){    Database.connect("jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;", "org.h2.Driver")    transaction {        SchemaUtils.create(Planetas)    }}
  • Usamos um bloco transaction pois toda conexo ao banco (escrita, leitura, edio e remoo) precisa estar dentro de um bloco transaction;
  • Passamos ao SchemaUtils.create o nosso objeto Planetas. Com isso, essa tabela ser criada no banco de dados;

Agora, vamos criar um bloco while (true) onde iremos executar um mesmo trecho de cdigo eternamente, onde iremos ler o nome, massa e se o planeta slido ou no, vamos enviar esses dados ao banco de dados, e tambm mostrar todas as linhas do banco na tela.

...fun main(){    Database.connect("jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;", "org.h2.Driver")    transaction {        SchemaUtils.create(Planetas)    }  while (true){  }}

Agora vamos usar a funo readLine para pegar os dados da linha de comando, mostrando na tela pergunta por pergunta:

...fun main(){    Database.connect("jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;", "org.h2.Driver")    transaction {        SchemaUtils.create(Planetas)    }  while (true){        print("Insira o nome do planeta: ")        val nomePlaneta = readLine().toString()        print("Insira a massa do planeta: ")        val massaPlaneta = readLine().toString().toDouble()        print("O planeta  slido? [sim/no]: ")        val solidoPlaneta = readLine() == "sim"  }}
  • na varivel nomePlaneta apenas transformamos o texto escrito na linha de comando em String com .toString();
  • na varivel massaPlaneta primeiro transformamos o texto escrito em String, e depois transformamos essa String em Double. Para assim obtermos o nmero decimal da massa do planeta em relao terra;
  • na varivel solidoPlaneta testamos se o texto escrito igual "sim". se essa condio for verdadeira, o planeta slido. Se no, o planeta no slido;

Agora vamos executar a transao para inserirmos esses dados no banco:

...fun main(){    Database.connect("jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;", "org.h2.Driver")    transaction {        SchemaUtils.create(Planetas)    }  while (true){        print("Insira o nome do planeta: ")        val nomePlaneta = readLine().toString()        print("Insira a massa do planeta: ")        val massaPlaneta = readLine().toString().toDouble()        print("O planeta  slido? [sim/no]: ")        val solidoPlaneta = readLine() == "sim"    transaction {      Planetas.insert {        it[nome] = nomePlaneta        it[massa] = massaPlaneta        it[solido] = solidoPlaneta      }    }  }}
  • Para inserirmos esses dados, podemos usar a funo Planetas.insert, informando o valor de cada coluna do banco com it[COLUNA] = valor.

Agora j conseguimos escrever dados no banco. Por fim, vamos pegar todos os dados do banco, e mostrar na tela. Mostrando que realmente conseguimos escrever os dados. Primeiro, vamos pegar todas as linhas da tabela Planetas:

...fun main(){    Database.connect("jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;", "org.h2.Driver")    transaction {        SchemaUtils.create(Planetas)    }  while (true){        print("Insira o nome do planeta: ")        val nomePlaneta = readLine().toString()        print("Insira a massa do planeta: ")        val massaPlaneta = readLine().toString().toDouble()        print("O planeta  slido? [sim/no]: ")        val solidoPlaneta = readLine() == "sim"    transaction {      Planetas.insert {        it[nome] = nomePlaneta        it[massa] = massaPlaneta        it[solido] = solidoPlaneta      }    }    transaction {      val planetasSalvos = Planetas.selectAll()    }  }}

Agora vamos percorrer por todo essa lista de dados, e mostrar na tela planeta por planeta usando um .map:

...fun main(){  Database.connect("jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;", "org.h2.Driver")    transaction {      SchemaUtils.create(Planetas)    }  while (true){    print("Insira o nome do planeta: ")    val nomePlaneta = readLine().toString()    print("Insira a massa do planeta: ")    val massaPlaneta = readLine().toString().toDouble()    print("O planeta  slido? [sim/no]: ")    val solidoPlaneta = readLine() == "sim"    transaction {      Planetas.insert {        it[nome] = nomePlaneta          it[massa] = massaPlaneta          it[solido] = solidoPlaneta      }    }    transaction {      val planetasSalvos = Planetas.selectAll()      planetasSalvos.map {        if (it[Planetas.solido]){          println("Planeta ${it[Planetas.nome]} tem ${it[Planetas.massa]} massas terrestres e  slido")        }else{          println("Planeta ${it[Planetas.nome]} tem ${it[Planetas.massa]} massas terrestres e no  slido")        }      }    }  }}
  • Dentro de um map, percorrermos elemento por elemento, e para nos referirmos ao elemento atual, podemos usar a varivel it. e dentro desse it podemos pegar os valores de cada linha, podendo assim mostrar na tela;

Agora, executando esse programa, poderemos ver na prtica como criamos um cdigo que pode inserir e ler dados de maneira dinmica:

Insira o nome do planeta: MercrioInsira a massa do planeta: 0.1O planeta  slido? [sim/no]: simPlaneta Mercrio tem 0.1 massas terrestres e  slidoInsira o nome do planeta: VnusInsira a massa do planeta: 0.9O planeta  slido? [sim/no]: simPlaneta Mercrio tem 0.1 massas terrestres e  slidoPlaneta Vnus tem 0.9 massas terrestres e  slido

Update e Delete

Duas operaes que no usamos foram a Updatee Delete. Essas duas so muito parecidas em seu uso na Exposed. Pois nas duas (quase sempre) necessrio usar um parmetro WHERE para definir quais linhas desejamos mudar/remover. Por exemplo, podemos fazer um Update com WHERE colocando a condio como argumento da funo, e a alterao em si no corpo. Dessa maneira:

transaction {  Planetas.update({ Planetas.nome eq "teste" }){    it[Planetas.nome] = "Vnus"  }}
  • Colocamos a condio entre {} como argumento da funo, e no corpo alteramos a linha diretamente;

E para o Delete podemos fazer a mesma coisa, mas agora apenas precisamos colocar a condio:

transaction {  Planetas.deleteWhere { Planetas.nome eq "teste" }}

Usando outros bancos de dados

Caso voc queira usar os outros bancos de dados que a Exposed suporta, voc pode ver a lista de URL's de conexo de diferentes bancos. Essa lista pode ser acessada clicando aqui

Finalizao

Nesse artigo voc aprendeu como usar de forma bsica a biblioteca Exposed, para escrever, ler, editar e remover dados de um banco.

Obrigado por ler


Original Link: https://dev.to/kotlinautas/usando-a-biblioteca-exposed-442

Share this article:    Share on Facebook
View Full Article

Dev To

An online community for sharing and discovering great ideas, having debates, and making friends

More About this Source Visit Dev To