#43: Upgrade Slick version and add Slick-pg dependency (#45)

* Introduced slick-pg optional dependency to increase the number of supported types
* created a Slick profile to use the Slick-pg types (most of them)
* added implicits to use with UUID type
* `SlickPgFunction` and `SlickPgFunctionWithStatusSupport` traits were renamed to `SlickFunction` and `SlickFunctionWithStatusSupport`as they are not really Postgres dependent
* added new alternative constructor to `DBSchema` and `DBFunction`
* extended `README.md` to contain info on Slick module and integration tests

Author: benedeki

README.md

@@ -13,7 +13,8 @@ ___
 - [What is fa-db](#what-is-fa-db)
 - [Usage](#usage)
 - [Concepts](#concepts)
-- [How to generate code coverage report](#how-to-generate-code-coverage-report)
+- [Slick module](#slick-module)
+- [Testing](#testing)
 - [How to Release](#how-to-release)
 <!-- tocstop -->
 
@@ -49,7 +50,7 @@ within the application.**
 Currently, the library is developed with Postgres as the target DB. But the approach is applicable to any DB supporting stored procedure/functions – Oracle, MS-SQL, ...
 
 
-### Usage
+## Usage
 
 #### Sbt
 
@@ -105,15 +106,65 @@ Modules:
 
 Text about status codes returned from the database function can be found [here](core/src/main/scala/za/co/absa/fadb/status/README.md).
 
-## How to generate code coverage report
+
+## Slick module
+
+Slick module is the first (and so far only) implementation of fa-db able to execute. As the name suggests it runs on 
+[Slick library](https://github.com/slick/slick) and also brings in the [Slickpg library](https://github.com/tminglei/slick-pg/) for extended Postgres type support.
+
+It brings:
+
+* `class SlickPgEngine` - implementation of _Core_'s `DBEngine` executing the queries via Slick
+* `trait SlickFunction` and `trait SlickFunctionWithStatusSupport` - mix-in traits to use with `FaDbFunction` descendants
+* `trait FaDbPostgresProfile` - to bring support for Postgres and its extended data types in one class (except JSON, as there are multiple implementations for this data type in _Slick-Pg_)
+* `object FaDbPostgresProfile` - instance of the above trait for direct use
+
+#### Known issues
+
+When getting result from `PositionedResult` for these types `HStore` -> `Option[Map[String, String]]` and 
+`macaddr` -> `MacAddrString` type inference doesn't work well.
+So instead of:
+```scala
+val pr: PositionedResult = ???
+val hStore: Option[Map[String, String]] = pr.<<
+val macAddr: Option[MacAddrString] = pr.<<
+```
+
+explicit extraction needs to be used:
+```scala
+val pr: PositionedResult = ???
+val hStore: Option[Map[String, String]] = pr.nextHStoreOption
+val macAddr: Option[MacAddrString] = pr.nextMacAddrOption
+```
+
+## Testing
+
+### How to generate unit tests code coverage report
+
 ```sbt
 sbt jacoco
 ```
+
 Code coverage will be generated on path:
+
 ```
 {project-root}/fa-db/{module}/target/scala-{scala_version}/jacoco/report/html
 ```
 
+### Integration tests
+
+There are now integration tests as part of the project (at the time of writing they are in the _Slick_ module).
+
+For the tests to work properly a running Postgres instance is needed. And then the following setup:
+* execute (content of) all `*.sql` files within `it/resources/sql/` folder within a posgres query tool
+* modify `it/resources/application.conf` to point to the database used in the previous point
+
+How to execute the tests:
+
+```sbt
+sbt it:test
+```
+
 ## How to Release
 
 Please see [this file](RELEASE.md) for more details.

build.sbt

@@ -42,10 +42,12 @@ lazy val commonJacocoReportSettings: JacocoReportSettings = JacocoReportSettings
   formats = Seq(JacocoReportFormats.HTML, JacocoReportFormats.XML)
 )
 
+
+/**
+  * add `za.co.absa.fadb.naming.NamingConvention`  to filter a class
+  * or  `za.co.absa.fadb.naming.NamingConvention*` to filter the class and all related objects
+  */
 lazy val commonJacocoExcludes: Seq[String] = Seq(
-  "za.co.absa.fadb.package*"
-  //        "za.co.absa.fadb.naming_conventions.SnakeCaseNaming*", // class and related objects
-  //        "za.co.absa.fadb.naming_conventions.AsIsNaming" // class only
 )
 
 lazy val parent = (project in file("."))
@@ -55,36 +57,41 @@ lazy val parent = (project in file("."))
     libraryDependencies ++= rootDependencies(scalaVersion.value),
     javacOptions ++= commonJavacOptions,
     scalacOptions ++= commonScalacOptions,
-    publish / skip := true
+    publish / skip := true,
+    Defaults.itSettings
   )
 
 lazy val faDbCore = (project in file("core"))
+  .configs(IntegrationTest)
   .settings(
     name := "core",
     libraryDependencies ++= coreDependencies(scalaVersion.value),
     javacOptions ++= commonJavacOptions,
     scalacOptions ++= commonScalacOptions,
-    (Compile / compile) := ((Compile / compile) dependsOn printScalaVersion).value // printScalaVersion is run with compile
+    (Compile / compile) := ((Compile / compile) dependsOn printScalaVersion).value, // printScalaVersion is run with compile
   )
   .settings(
     jacocoReportSettings := commonJacocoReportSettings.withTitle(s"fa-db:core Jacoco Report - scala:${scalaVersion.value}"),
     jacocoExcludes := commonJacocoExcludes
   )
 
 lazy val faDBSlick = (project in file("slick"))
+  .configs(IntegrationTest)
   .settings(
     name := "slick",
     libraryDependencies ++= slickDependencies(scalaVersion.value),
     javacOptions ++= commonJavacOptions,
     scalacOptions ++= commonScalacOptions,
-    (Compile / compile) := ((Compile / compile) dependsOn printScalaVersion).value // printScalaVersion is run with compile
+    (Compile / compile) := ((Compile / compile) dependsOn printScalaVersion).value, // printScalaVersion is run with compile
+    Defaults.itSettings,
   ).dependsOn(faDbCore)
   .settings(
     jacocoReportSettings := commonJacocoReportSettings.withTitle(s"fa-db:slick Jacoco Report - scala:${scalaVersion.value}"),
     jacocoExcludes := commonJacocoExcludes
   )
 
 lazy val faDBExamples = (project in file("examples"))
+  .configs(IntegrationTest)
   .settings(
     name := "examples",
     libraryDependencies ++= examplesDependencies(scalaVersion.value),

core/src/main/scala/za/co/absa/fadb/DBFunction.scala

@@ -34,6 +34,11 @@ abstract class DBFunction[I, R, E <: DBEngine](functionNameOverride: Option[Stri
                                               (implicit val schema: DBSchema, val dBEngine: E) extends DBFunctionFabric {
 
   /* alternative constructors for different availability of input parameters */
+  def this(functionNameOverride: String)
+          (implicit schema: DBSchema, dBEngine: E) = {
+    this(Option(functionNameOverride))(schema, dBEngine)
+  }
+
   def this(schema: DBSchema, functionNameOverride: String)
           (implicit dBEngine: E) = {
     this(Option(functionNameOverride))(schema, dBEngine)
@@ -106,6 +111,11 @@ object DBFunction {
                                                               (implicit schema: DBSchema, dBEngine: E)
     extends DBFunction[I, R, E](functionNameOverride) {
 
+    def this(functionNameOverride: String)
+            (implicit schema: DBSchema, dBEngine: E) = {
+      this(Option(functionNameOverride))(schema, dBEngine)
+    }
+
     def this(schema: DBSchema, functionNameOverride: String)
             (implicit dBEngine: E) = {
       this(Option(functionNameOverride))(schema, dBEngine)
@@ -150,6 +160,11 @@ object DBFunction {
                                                             (implicit schema: DBSchema, dBEngine: E)
     extends DBFunction[I, R, E](functionNameOverride) {
 
+    def this(functionNameOverride: String)
+            (implicit schema: DBSchema, dBEngine: E) = {
+      this(Option(functionNameOverride))(schema, dBEngine)
+    }
+
     def this(schema: DBSchema, functionNameOverride: String)
             (implicit dBEngine: E) = {
       this(Option(functionNameOverride))(schema, dBEngine)
@@ -193,6 +208,11 @@ object DBFunction {
                                                               (implicit schema: DBSchema, dBEngine: E)
     extends DBFunction[I, R, E](functionNameOverride) {
 
+    def this(functionNameOverride: String)
+            (implicit schema: DBSchema, dBEngine: E) = {
+      this(Option(functionNameOverride))(schema, dBEngine)
+    }
+
     def this(schema: DBSchema, functionNameOverride: String)
             (implicit dBEngine: E) = {
       this(Option(functionNameOverride))(schema, dBEngine)

core/src/main/scala/za/co/absa/fadb/DBSchema.scala

@@ -30,6 +30,11 @@ import za.co.absa.fadb.naming.NamingConvention
 abstract class DBSchema(schemaNameOverride: Option[String] = None)
                        (implicit dBEngine: DBEngine, implicit val namingConvention: NamingConvention) {
 
+  def this(schemaNameOverride: String)
+          (implicit dBEngine: DBEngine, namingConvention: NamingConvention) {
+    this(Option(schemaNameOverride))(dBEngine, namingConvention)
+  }
+
   def this(dBEngine: DBEngine, schemaNameOverride: String)
           (implicit namingConvention: NamingConvention) {
     this(Option(schemaNameOverride))(dBEngine, namingConvention)

examples/src/main/scala/za/co/absa/fadb/examples/enceladus/DatasetSchema.scala

@@ -17,7 +17,7 @@
 package za.co.absa.fadb.examples.enceladus
 
 import za.co.absa.fadb.DBSchema
-import za.co.absa.fadb.slick.{SlickPgEngine, SlickPgFunction, SlickPgFunctionWithStatusSupport}
+import za.co.absa.fadb.slick.{SlickPgEngine, SlickFunction, SlickFunctionWithStatusSupport}
 import za.co.absa.fadb.naming.implementations.SnakeCaseNaming.Implicits.namingConvention
 import slick.jdbc.{GetResult, SQLActionBuilder}
 import slick.jdbc.PostgresProfile.api._
@@ -63,7 +63,7 @@ object DatasetSchema {
 
   final class AddSchema(implicit override val schema: DBSchema, override val dbEngine: SlickPgEngine)
     extends DBSingleResultFunction[SchemaInput, Long, SlickPgEngine]
-    with SlickPgFunctionWithStatusSupport[SchemaInput, Long]
+    with SlickFunctionWithStatusSupport[SchemaInput, Long]
     with UserDefinedStatusHandling {
 
     override protected def sql(values: SchemaInput): SQLActionBuilder = {
@@ -81,7 +81,7 @@ object DatasetSchema {
 
   final class GetSchema(implicit override val schema: DBSchema, override val dbEngine: SlickPgEngine)
     extends DBSingleResultFunction[(String, Option[Int]), Schema, SlickPgEngine]
-    with SlickPgFunctionWithStatusSupport[(String, Option[Int]), Schema]
+    with SlickFunctionWithStatusSupport[(String, Option[Int]), Schema]
     with UserDefinedStatusHandling {
 
     /* This is an example of how to deal with overloaded DB functions - see different input type: Long vs what's in the class type: (String, Option[Int]) */
@@ -108,7 +108,7 @@ object DatasetSchema {
 
   final class List(implicit override val schema: DBSchema, override val dbEngine: SlickPgEngine)
     extends DBMultipleResultFunction[Boolean, SchemaHeader, SlickPgEngine]()
-    with SlickPgFunction[Boolean, SchemaHeader] {
+    with SlickFunction[Boolean, SchemaHeader] {
 
     override def apply(values: Boolean = false): Future[Seq[SchemaHeader]] = super.apply(values)
 

project/Dependencies.scala

@@ -20,9 +20,9 @@ object Dependencies {
 
 
   private def commonDependencies(scalaVersion: String): Seq[ModuleID] = Seq(
-    "org.scalatest"      %% "scalatest" % "3.1.0"           % Test,
-    "org.scalatest"      %% "scalatest-flatspec" % "3.2.0"  % Test,
-    "org.scalatestplus"  %% "mockito-1-10" % "3.1.0.0"      % Test
+    "org.scalatest"      %% "scalatest" % "3.1.0"           % "test,it",
+    "org.scalatest"      %% "scalatest-flatspec" % "3.2.0"  % "test,it",
+    "org.scalatestplus"  %% "mockito-1-10" % "3.1.0.0"      % "test,it"
   )
 
   def rootDependencies(scalaVersion: String): Seq[ModuleID] = Seq()
@@ -35,9 +35,10 @@ object Dependencies {
   def slickDependencies(scalaVersion: String): Seq[ModuleID] = {
     commonDependencies(scalaVersion) ++ Seq(
       "com.typesafe.slick"  %% "slick"                        % "3.3.3",
-      "org.slf4j"            % "slf4j-nop"                    % "1.6.4",
+      "org.slf4j"            % "slf4j-nop"                    % "1.7.26",
       "com.typesafe.slick"  %% "slick-hikaricp"               % "3.3.3",
-      "org.postgresql"       % "postgresql"                   % "9.4-1206-jdbc42",
+      "org.postgresql"       % "postgresql"                   % "42.6.0",
+      "com.github.tminglei" %% "slick-pg"                     % "0.20.4"   % Optional
     )
   }
 

slick/src/it/resources/application.conf

@@ -0,0 +1,12 @@
+postgrestestdb = {
+  connectionPool = "HikariCP" //use HikariCP for our connection pool
+  dataSourceClass = "org.postgresql.ds.PGSimpleDataSource" //Simple datasource with no connection pooling. The connection pool has already been specified with HikariCP.
+  properties = {
+    serverName = "localhost"
+    portNumber = "5432"
+    databaseName = "postgres"
+    user = "postgres"
+    password = "changeme"
+  }
+  numThreads = 10
+}

slick/src/it/resources/sql/test_function.sql

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2022 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+CREATE EXTENSION IF NOT EXISTS hstore;
+
+CREATE EXTENSION IF NOT EXISTS ltree;
+
+CREATE OR REPLACE FUNCTION public.test_function(
+    IN  i_uuid1             UUID,
+    IN  i_dateTime1         DATE,
+    IN  i_dateTime2         TIME,
+    IN  i_dateTime3         TIMESTAMP WITHOUT TIME ZONE,
+    IN  i_dateTime4         INTERVAL,
+    IN  i_dateTime5         TIMESTAMP WITH TIME ZONE,
+    IN  i_dateTime6         TIMESTAMP WITH TIME ZONE,
+    IN  i_range1            INT4RANGE,
+    IN  i_ltree1            LTREE,
+    IN  i_map1              HSTORE,
+    IN  i_inet1             INET,
+    IN  i_macaddr1          MACADDR,
+    OUT uuid1               UUID,
+    OUT dateTime1           DATE,
+    OUT dateTime2           TIME,
+    OUT dateTime3           TIMESTAMP WITHOUT TIME ZONE,
+    OUT dateTime4           INTERVAL,
+    OUT dateTime5           TIMESTAMP WITH TIME ZONE,
+    OUT dateTime6           TIMESTAMP WITH TIME ZONE,
+    OUT range1              INT4RANGE,
+    OUT ltree1              LTREE,
+    OUT map1                HSTORE,
+    OUT inet1               INET,
+    OUT macaddr1            MACADDR
+) RETURNS record AS
+$$
+-------------------------------------------------------------------------------
+--
+-- Function: test_function(12)
+--      A function to test Fa-Db Slick Posgres special time enhancement. Function works as a mirror. Returns what came in.
+--
+--
+-- Returns:
+--      input is returned unchanged
+--
+-------------------------------------------------------------------------------
+DECLARE
+BEGIN
+    uuid1       := i_uuid1;
+    dateTime1   := i_dateTime1;
+    dateTime2   := i_dateTime2;
+    dateTime3   := i_dateTime3;
+    dateTime4   := i_dateTime4;
+    dateTime5   := i_dateTime5;
+    dateTime6   := i_dateTime6;
+    range1      := i_range1;
+    ltree1      := i_ltree1;
+    map1        := i_map1;
+    inet1       := i_inet1;
+    macaddr1    := i_macaddr1;
+
+    RETURN;
+END;
+$$
+LANGUAGE plpgsql VOLATILE SECURITY DEFINER;
+
+GRANT EXECUTE ON FUNCTION test_function(
+    UUID,
+    DATE,
+    TIME,
+    TIMESTAMP WITHOUT TIME ZONE,
+    INTERVAL,
+    TIMESTAMP WITH TIME ZONE,
+    TIMESTAMP WITH TIME ZONE,
+    INT4RANGE,
+    LTREE,
+    HSTORE,
+    INET,
+    MACADDR
+    ) TO postgres;