aboutsummaryrefslogtreecommitdiff
path: root/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala
blob: e2936e39f3080384c487bb1c2905b7fc1247f4f0 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package xyz.driver.pdsuicommon.db

import java.sql.ResultSet

import xyz.driver.pdsuicommon.logging._
import io.getquill.{MySQLDialect, MysqlEscape}

import scala.collection.breakOut

object MysqlQueryBuilder extends PhiLogging {
  import xyz.driver.pdsuicommon.db.QueryBuilder._

  def apply[T](tableName: String,
               lastUpdateFieldName: Option[String],
               nullableFields: Set[String],
               links: Set[TableLink],
               runner: Runner[T],
               countRunner: CountRunner): MysqlQueryBuilder[T] = {
    val parameters = MysqlQueryBuilderParameters(
      tableData = TableData(tableName, lastUpdateFieldName, nullableFields),
      links = links.map(x => x.foreignTableName -> x)(breakOut)
    )
    new MysqlQueryBuilder[T](parameters)(runner, countRunner)
  }

  def apply[T](tableName: String,
               lastUpdateFieldName: Option[String],
               nullableFields: Set[String],
               links: Set[TableLink],
               extractor: (ResultSet) => T)(implicit sqlContext: MySqlContext): MysqlQueryBuilder[T] = {

    val runner: Runner[T] = { parameters =>
      val (sql, binder) = parameters.toSql(namingStrategy = MysqlEscape)
      logger.trace(phi"Query for execute: ${Unsafe(sql)}")
      sqlContext.executeQuery[T](sql, binder, { resultSet =>
        extractor(resultSet)
      })
    }

    val countRunner: CountRunner = { parameters =>
      val (sql, binder) = parameters.toSql(countQuery = true, namingStrategy = MysqlEscape)
      logger.trace(phi"Query for execute: ${Unsafe(sql)}")
      sqlContext
        .executeQuery[CountResult](
          sql,
          binder, { resultSet =>
            val count = resultSet.getInt(1)
            val lastUpdate = if (parameters.tableData.lastUpdateFieldName.isDefined) {
              Option(sqlContext.localDateTimeDecoder.decoder(2, resultSet))
            } else None

            (count, lastUpdate)
          }
        )
        .head
    }

    apply[T](
      tableName = tableName,
      lastUpdateFieldName = lastUpdateFieldName,
      nullableFields = nullableFields,
      links = links,
      runner = runner,
      countRunner = countRunner
    )
  }
}

class MysqlQueryBuilder[T](parameters: MysqlQueryBuilderParameters)(implicit runner: QueryBuilder.Runner[T],
                                                                    countRunner: QueryBuilder.CountRunner)
    extends QueryBuilder[T, MySQLDialect, MysqlEscape](parameters) {

  def withFilter(newFilter: SearchFilterExpr): QueryBuilder[T, MySQLDialect, MysqlEscape] = {
    new MysqlQueryBuilder[T](parameters.copy(filter = newFilter))
  }

  def withSorting(newSorting: Sorting): QueryBuilder[T, MySQLDialect, MysqlEscape] = {
    new MysqlQueryBuilder[T](parameters.copy(sorting = newSorting))
  }

  def withPagination(newPagination: Pagination): QueryBuilder[T, MySQLDialect, MysqlEscape] = {
    new MysqlQueryBuilder[T](parameters.copy(pagination = Some(newPagination)))
  }

  def resetPagination: QueryBuilder[T, MySQLDialect, MysqlEscape] = {
    new MysqlQueryBuilder[T](parameters.copy(pagination = None))
  }
}