Integración de Play con Slick y SQLite en Scala

Curso de Scala básico

Contenido del curso

Introducción a Scala y configuración del entorno de desarrollo

Fundamentos de Programación Funcional

Conceptos básicos de Programación Funcional

Fundamentos teoricos

Proyecto de Backend

Conclusiones

36
Conceptos Clave de la Programación Funcional en Scala
02:24 min

Tomar examen

Antes de empezar, deberías descargar el template Play Scala Seed desde esta página: https://developer.lightbend.com/start/?group=play&project=play-scala-seed

Recuerda que para este proyecto usaremos IntelliJ IDEA como editor, así que asegúrate de tenerlo instalado junto con los plugins recomendados en una lectura anterior. Debes tener abierto el proyecto en el IntelliJ IDEA.

El proceso que seguiremos será el siguiente:

Instalaremos las dependencias de Slick y el Driver de la base de datos.
Agregaremos las configuraciones para la conexión con la base de datos.
Crearemos un archivo Movie.scala con el modelo y la definición de la tabla.
Haremos el esqueleto de funciones para la clase siguiente.
Agregaremos una función de ayuda para crear la base de datos.

Dependencias

Lo primero que hay que agregar son las dependencias para usar PlaySlick (el plugin que integra Play con Slick), y el driver JDBC de la base de datos que vayamos a usar, que en este caso será SQLite.

SBT buscará los paquetes de sus dependencias en Maven.

Puedes pensar en Maven como algo similar a NPM de JavaScript (un repositorio de paquetes que pueden ser descargados). Aunque la diferencia con NPM es que Maven no constituye una entidad única si no múltiples repositorios de paquetes administrados por diferentes entidades o empresas.

Por eso para encontrar nuevos paquetes existe una página que tiene indexados más de mil repositorios de Maven: https://mvnrepository.com/

Allí es fácil hacer búsquedas no solo de los paquetes que necesitemos, si no también de sus versiones disponibles.

Como ejercicio, haz tú la búsqueda de los dos paquetes que queremos instalar. En la siguiente imagen puedes ver cómo debe quedar el build.sbt:

Luego con el comando sbt update desde la consola, haremos que sbt descargue estas dependencias en nuestro proyecto para que estén disponibles.

Configuración

Lo siguiente que debes hacer, es configurar los datos de acceso a una base de datos SQLite. Esto lo haremos en el archivo application.conf que se encuentra en la carpeta conf del proyecto.

El archivo application.conf está escrito en un formato llamado HOCON. En la imagen estamos definiendo las configuraciones para la base de datos por defecto (Slick permite configurar múltiples conexiones al tiempo también). Las configuraciones mínimas son las siguientes:

Profile: Le dice a Slick el perfil de la base de datos que vamos a usar. Hay que notar el símbolo $ al final de la clase SQLiteProfile. Puedes ver un listado de las bases de datos soportadas con los links a sus perfiles en la documentación de Slick, https://scala-slick.org/doc/3.3.1/supported-databases.html
Driver: Es el driver que Slick usará para comunicarse con la base de datos. JDBC es un estándar para controladores de bases de datos en Java. Todas las bases de datos populares tienen un driver JDBC y en nuestro caso, será el path al que instalamos como dependencia.
Url: Es la dirección de conexión a la base de datos. Para el caso particular de SQLite, MyDataBase.db será el nombre del archivo donde se alojará la base de datos. No es necesario que exista con antelación ya que más adelante haremos que play lo cree por nosotros. En otras bases de datos como Postgres, Oracle o MySql, la URL de conexión será distinta, pero siempre siguiendo su formato para JDBC.
User y Password: Para este proyecto, nuestra base de datos en SQLite no tiene ni usuario ni contraseña, lo hacemos así por simplicidad pero en proyectos reales tu base de datos debe tener usuario y clave seguros.
El último parámetro (slick.default), hace referencia al paquete de Scala donde Slick buscará las clases cuando hagamos la definición de los modelos.

Modelo

En la carpeta app, crearemos un paquete que se llame models, y dentro crearemos un archivo llamado Movie.scala. Puedes crearlos con clic derecho New, o creando la carpeta y el archivo manualmente. Debe quedarte de la siguiente manera:

Case Class Movie

Lo primero será convertir la clase Movie en un case class, y agregarle los atributos correspondientes. Este case class debe quedar de la siguiente manera:

Los puntos a notar son:

Usamos paréntesis () en vez de llaves {}.
Los atributos id y tags son opcionales, pero el primero crea por defecto un UUID (que debes de importar) cuando el objeto no tenga id.

MovieTable

Teniendo ya el case class, debemos crear una clase que será el "puente" entre la información que se envíe/reciba de la base de datos, hacia el objeto de Scala.

Esta clase la llamaremos MovieTable y puede estar en el mismo archivo, junto con la case class Movie (a diferencia de Java, en Scala podemos tener distintas clases en el mismo archivo sin problema). Debe quedar de la siguiente manera:

Se debe importar el contenido del objeto api que está en el profile de nuestra base de datos SQLite (en Scala el guión bajo _ en una importación, es equivalente al asterisco * de Java o Python).
La clase extiende de un trait llamado Table[T] que recibe un tipo de dato T, que en este caso será el case class Movie. Allí también de le dice el nombre de la tabla de SQL a la que hace referencia.
Cada atributo se define con un tipo column, dándole el tipo de dato de Scala, y el nombre de la columna en SQL.
Algunos atributos tienen opciones especiales, como el id que tiene O.PrimaryKey, o tags que tiene O.Length(2000, varying = true) . Existen varias opciones que están dentro del objeto O de opciones de columna. Las opciones disponibles siempre depende de la base de datos que estés usando.
La definición del id en la tabla es directamente un String en vez de un Option[String]. Esto es porque la clave primaria nunca puede ser nula.
Hay una definición especial que describe la proyección entre el objeto tabla y la case class a la que mapea. El nombre que tiene es un asterisco *. Para el atributo id.?, ese ? es necesario porque en la definición de la tabla ese atributo es obligatorio, pero en la definición del objeto es opcional, de esa manera el compilador sabe que lo debe transformar.

Si quieres conocer más detalles sobre esto, puedes verlos en la documentación de Slick: https://scala-slick.org/doc/3.3.1/schemas.html

MovieRepository

La última parte en este archivo será lo que se conoce como repositorio.

En este contexto, un repositorio es el encargado de comunicar la base de datos con lo que será más adelante el controlador. Esta será la clase sobre la que vamos a trabajar en la próxima clase.

El repositorio debe quedar de la siguiente manera:

Hay varias clases que es necesario importarlas, y que luego serán "inyectadas" haciendo uso de un patrón conocido como Inyección de dependencias. No es el objetivo explicar eso aquí, lo importante es entender que una instancia esas clases va a estar disponible dentro de la clase repositorio luego de ser inyectada.
El objeto inyectado dbConfigProvider contiene lo necesario para realizar peticiones a la base de datos, usando los datos que escribiste en el application.conf.
El contexto de ejecución es usado para realizar las peticiones de manera asíncrona. Más adelante veremos esto en detalle. Se usa la palabra reservada implicit para no tener que pasarle este parámetro todo el tiempo, si no que el compilador lo ponga por nosotros.
El atributo movieQuery, es desde el cual vamos a estar creando las peticiones a la base de datos en la próxima clase.

Funciones de ayuda para la creación de la base de datos

Esta parte no la explicaré en detalle, pero será útil para crear el esquema de la base de datos usando lo que acabamos de escribir. Es decir, que no es necesario tener las definiciones de las tablas en SQL, si no que con base en el código en Scala, podemos decirle a Slick que las cree por nosotros.

En el repositorio

Para ello, primero debes agregar el siguiente código dentro de la clase MovieRepository:

  // Esto va dentro de la clase MovieRepository
 
  /**
   * Función de ayuda para crear la tabla si ésta
   * aún no existe en la base de datos.
   * @return
   */
  def dbInit: Future[Unit] = {
    // Definición de la sentencia SQL de creación del schema
    val createSchema = movieQuery.schema.createIfNotExists
    // db.run Ejecuta una sentencia SQL, devolviendo un Future
    db.run(createSchema)
  }

  def getAll = ???
  def getOne = ???
  def create = ???
  def update = ???
  def delete = ???

Nota que la última parte en donde están los ???, es donde empezaremos en la próxima clase.

En el HomeController

Luego debes agregar lo siguiente en el archivo app/controllers/HomeController.scala

// Importar el repository y el contexto de ejecución global
import models.MovieRepository
import scala.concurrent.ExecutionContext.Implicits.global

//....

// Hay que agregar el repository para que sea inyectado
@Singleton
class HomeController @Inject()(
    cc: ControllerComponents,
    movieRepository: MovieRepository
) extends AbstractController(cc) {

  // .....

  /*
    Función de ayuda para crear la tabla si esta aún no existe.
   */
  def dbInit() = Action.async { request =>
    movieRepository.dbInit
      .map(_ => Created("Tabla creada"))
      .recover{ex =>
        play.Logger.of("dbInit").debug("Error en dbInit", ex)
        InternalServerError(s"Hubo un error")
      }
  }
}

Se importa el repositorio.
Se coloca el repositorio en la cabecera de la clase HomeController para que sea inyectado.
Se define la acción dbInit.

En el archivo de rutas

Por último se debe agregar en el archivo conf/routes una ruta hacia la acción dbInit que acabamos de agregar:

GET     /dbInit                     controllers.HomeController.dbInit

![07.png](https://static.platzi.com/media/user_upload/07-a0159219-ea8b-41fa-993d-3eadd97438e7.jpg

Corriendo el servidor y creando la base de datos

Usaremos en comando sbt compile para estar seguros que todo compila correctamente, y después escribimos el comando sbt run para correr el servidor en modo desarrollo.

Con el servidor de desarrollo encendido, visitaremos la dirección http://localhost:9000/dbInit, y después de unos segundos, deberías ver el mensaje de "Tabla creada".

Y si revisas la carpeta del proyecto, deberías ver el archivo de la base de datos SQLite también:

Para detener el servidor de desarrollo, usa las teclas Ctrl+D en la consola.

Conclusiones

En esta clase escrita aprendimos muchas habilidades útiles para trabajar con Play y Scala.

Aquí fuimos a lo práctico, pero por supuesto hay temas que se profundizan en la documentación de Play y que quizás te puedan interesar: https://www.playframework.com/documentation/2.7.x/PlaySlick

Estoy seguro que en el código de esta clase notaste cómo aplicamos varios de los temas que vimos en las clases pasadas. Escribe en los comentarios cuales viste que te llamaron la atención, y por qué crees que son útiles o inútiles en donde fueron aplicados.

Integración de Play con Slick y SQLite en Scala

Antonio Rafael González Ferrer

Estudiante

Obtengo errores en todo 😑

Imágenes:

El error en navegador:

IO error while decoding C:\Users\sistemasfimtt\iCloudDrive\Platzi\Carreras\Fundamentos de Programación\ProgramacionFuncionalConScala\play-scala-seed\target\scala-2.13\routes\main\controllers\ReverseRoutes.scala with UTF-8: MALFORMED[1]
Please try specifying another one using the -encoding option

Mis archivos: build.sbt

name := """platzi-video"""
organization := "com.platzi"

version := "1.0-SNAPSHOT"

lazy val root = (project in file(".")).enablePlugins(PlayScala)

scalaVersion := "2.13.1"

libraryDependencies += guice
libraryDependencies += "org.scalatestplus.play" %% "scalatestplus-play" % "5.0.0" % Test
libraryDependencies += "com.typesafe.play" %% "play-slick" % "4.0.2"
libraryDependencies += "org.xerial" % "sqlite-jdbc" % "3.28.0"

application.conf

# https://www.playframework.com/documentation/latest/Configuration

slick.dbs.default.profile="slick.jdbc.SQLiteProfiles$"
slick.dbs.default.db.driver="org.sqlite.JDBC"
slick.dbs.default.db.url="jdbc:sqlite:MyDataBase.db"
slick.dbs.default.db.user=""
slick.dbs.default.db.password=""

slick.default="model.*"

Movie.scala

package models
import java.util.UUID

/*
  Objeto Movie.
 */
case class Movie(
  id: Option[String] = Option(UUID.randomUUID.toString),
  title: String,
  year: Int,
  cover: String,
  description: String,
  duration: Int,
  contentRating: String,
  source: String,
  tags: Option[String]
)

MovieTable.scala

package models
import slick.jdbc.SQLiteProfile.api_
/*
  Clase que mapea el objeto a la tabla movie.

  https://scala-slick.org/doc/3.3.1/schemas.html
 */
class MovieTable(tag: Tag) extends TableMovie{
  def id: Rep[String] = columnString
  def title: Rep[String] = columnString
  def year: Rep[Int] = columnInt
  def cover: Rep[String] = columnString
  def description: Rep[String] = columnString
  def duration: Rep[Int] = columnInt
  def contentRating: Rep[String] = columnString
  def source: Rep[String] = columnString
  def tags: Rep[Option[String]] = column[Option[String]]("tags", 0.Lenght(2000, varying = true))

  def *: ProvenShape[Movie] = (id.?, title, year, cover, duration, contentRating, source, tags) <> (Movie.tupled, Movie.unapply)
}

MovieRepository.scala

package models
import javax.inject.Inject
import play.api.db.slick.{DatabaseConfigProvider, HasDatabaseConfigProvider}
import play.api.mvc.{AbstractController, ControllerComponents}
import scala.concurrent.{ExecutionContext, Future}
/*
  Clase repository, donde irán las consultas.
 */
class MovieRepository @Inject()(
  protected val dbConfigProvider: DatabaseConfigProvider, cc: ControllerComponents
)(implicit ec: ExecutionContext)
  extends AbstractController(cc)
  with HasDatabaseConfigProvider[JdbcProfile]{
  private lazy val movieQuery = TableQuery[MovieTable]
}
/*
  * Función de ayuda para crear la tabla si esta
  * aún no existe en la base de datos.
  * @return
 */
def dbInit: Future[Unit] = {
  // Definición de la sentencia SQL de creación del schema
  val createSchema = movieQuery.schema.createIfNotExists
  // db.run ejecuta una secuencia SQL, devolviendo un Future
  db.run(createSchema)
}

def getAll = ???
def getOne = ???
def create = ???
def update = ???
def delete = ???

HomeController.scala

package controllers

import javax.inject._
import play.api._
import play.api.mvc._
// Importar el repository y el contexto de ejecución global
import models.MovieRepository
import scala.concurrent.ExecutionContext.Implicits.global

/**
 Hay quea gregar el repository para que sea inyectado
 */
@Singleton
class HomeController @Inject()(
  cc: ControllerComponents,
  movieRepository: MovieRepository
) extends AbstractController(cc){
  // ...
  /*
    Función de ayuda para crear la tabla si esta aún no existe
   */
  def dbInit() = Action.async{ request =>
    movieRepository.dbInit
      .map(_ => Created("Tabla creada"))
      .recover{ex =>
        play.Logger.of("dbInit").debug("Error en dbInit", ex)
        InternalServerError(s"Hubo un error")
      }
  }
}

routes

# Routes
# This file defines all application routes (Higher priority routes first)
# https://www.playframework.com/documentation/latest/ScalaRouting
# ~~~~

# An example controller showing a sample home page
GET     /                           controllers.HomeController.index

# Map static resources from the /public folder to the /assets URL path
GET     /assets/*file               controllers.Assets.versioned(path="/public", file: Asset)

GET     /dbInit                     controllers.HomeController.dbInit

¿Algún apoyo con el tema?

Nicolás Danilo Peña Fuentes

Estudiante

En la clase MovieTable tienes algunos errores de sintaxis. Revisa por ejemplo que estás llamando 0.PrimaryKey, y debería ser O.PrimaryKey (no es un cero, es la letra 'O') en el def tags colocas 0.Lenght, y es O.Length

C. Daniel Sanchez R.

Profesor

Hola. Uno de los errores puede ser por la tilde Programación en el nombre de la carpeta. También hay otro error en la importación del objeto api en MovieTable.scala, deberías ser slick.jdbc.SQLiteProfile.api._. Por supuesto, el apunte de dann es correcto en que no es un cero si no una O.

Jesus Rodriguez

Juan Quevedo Sanchez

Rafael Lizarraga

Sroba

Martin Albarracin

Jose Alvear

J. Fernando Zuñiga Ortiz

Elias Ojeda Medina

Fabricio Orrala

Daniel Jacales

Ezequiel Aguilar Benitez

Daniel Eduardo Portugal Revilla

Miguel Contreras

Alejandro Cabarcas Perdomo

Axel Alexis Montejo Lopez

Johan Nicolas Riaño Torres

Manuel Eguiluz

Carlos Cabrera

Daniel Horfan

Integración de Play con Slick y SQLite en Scala

Introducción a Scala y configuración del entorno de desarrollo

Introducción al curso y presentación de los objetivos

Programación Funcional en Scala: Fundamentos y Beneficios

Instalación y configuración de herramientas para programar en Scala

Herramientas Esenciales para Programar en Scala

Hola Mundo en Scala con ScalaFiddle

Fundamentos de Programación Funcional

Tipos de Datos Básicos en Scala

Inmutabilidad en Programación Funcional con Scala

Expresiones en Scala: Conceptos y Ejemplos Prácticos

Funciones en Programación Funcional y Matemática

Colecciones Inmutables en Lenguajes Funcionales

Tuplas y objetos en programación funcional y orientada a objetos

Uso de `copy()` y Lentes en Programación Funcional

Conceptos básicos de Programación Funcional

Programación Funcional: Uso de Pattern Matching Avanzado

Optimización de Algoritmos con Tail Recursion

Agregación y acumuladores en programación funcional con Scala

Fundamentos teoricos

Funciones Totales y Parciales en Programación Funcional

Razonamiento Inductivo en Algoritmos Recursivos

Razonamiento con Tipos en Lenguajes Tipados y Dinámicos

Uso de Traits en Scala: Concepto y Ejemplos Prácticos

Tipos Genéricos en Programación: Uso y Ejemplos Prácticos

Tipos de Datos Algebraicos: Suma y Producto en Programación

Evaluación Perezosa en Scala: Variables y Colecciones Lazy

Manejo de Disyunciones Option en Programación Funcional

Manejo de Excepciones con Try y Either en Programación Funcional

Proyecto de Backend

Desarrollo de Backend con PlayFramework y Scala: Proyecto Platzi Video

Modelo de Actores en Scala: Akka y Erlang

Modelo de Datos y Configuración de Proyecto con Play Framework

Integración de Play con Slick y SQLite en Scala

Consultas Asíncronas y Futuros en Scala con Slick

Creación, actualización y eliminación de datos en bases de datos

Computación Paralela y Asíncrona en Scala: Conceptos y Aplicaciones

Serialización de Datos en Scala con Play Framework

Serialización y validación de JSON a objetos Scala

Manejo de Errores en Scala: Técnicas y Pruebas con Postman

Exportación de Aplicaciones Play con SBT Native Packager

Conclusiones

Conceptos Clave de la Programación Funcional en Scala