From 91a4120b4253dc4a1e9552ec39fcb25c303a21e1 Mon Sep 17 00:00:00 2001 From: vlad Date: Tue, 13 Jun 2017 16:15:07 -0700 Subject: Scalafmt --- .../xyz/driver/pdsuicommon/db/DbCommand.scala | 2 +- .../driver/pdsuicommon/db/DbCommandFactory.scala | 4 +- .../pdsuicommon/db/EntityExtractorDerivation.scala | 22 +++-- .../pdsuicommon/db/EntityNotFoundException.scala | 4 +- .../driver/pdsuicommon/db/MysqlQueryBuilder.scala | 36 ++++---- .../xyz/driver/pdsuicommon/db/QueryBuilder.scala | 97 +++++++++++----------- .../driver/pdsuicommon/db/SearchFilterExpr.scala | 31 ++++--- .../scala/xyz/driver/pdsuicommon/db/Sorting.scala | 15 ++-- .../xyz/driver/pdsuicommon/db/SqlContext.scala | 48 +++++------ .../repositories/BridgeUploadQueueRepository.scala | 2 +- 10 files changed, 128 insertions(+), 133 deletions(-) (limited to 'src/main/scala/xyz/driver/pdsuicommon/db') diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala index 911ecee..5dafc00 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala @@ -9,7 +9,7 @@ trait DbCommand { object DbCommand { val Empty: DbCommand = new DbCommand { - override def runSync(): Unit = {} + override def runSync(): Unit = {} override def runAsync(transactions: Transactions): Future[Unit] = Future.successful(()) } } diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala index f12b437..1e2fb74 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala @@ -8,7 +8,7 @@ trait DbCommandFactory[T] { object DbCommandFactory { def empty[T]: DbCommandFactory[T] = new DbCommandFactory[T] { - override def createCommand(orig: T)(implicit ec: ExecutionContext): Future[DbCommand] = Future.successful(DbCommand.Empty) + override def createCommand(orig: T)(implicit ec: ExecutionContext): Future[DbCommand] = + Future.successful(DbCommand.Empty) } } - diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala b/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala index e13ea39..02ba322 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala @@ -8,13 +8,12 @@ import io.getquill.dsl.EncodingDsl import scala.language.experimental.macros import scala.reflect.macros.blackbox -trait EntityExtractorDerivation[Naming <: NamingStrategy] { - this: EncodingDsl => +trait EntityExtractorDerivation[Naming <: NamingStrategy] { this: EncodingDsl => - /** - * Simple Quill extractor derivation for [[T]] - * Only case classes available. Type parameters is not supported - */ + /* + Simple Quill extractor derivation for [[T]] + Only case classes available. Type parameters is not supported + */ def entityExtractor[T]: (ResultSet => T) = macro EntityExtractorDerivation.impl[T] } @@ -34,16 +33,16 @@ object EntityExtractorDerivation { case cons: MethodSymbol if cons.isConstructor => // Create param list for constructor val params = cons.paramLists.flatten.map { param => - val t = param.typeSignature + val t = param.typeSignature val paramName = param.name.toString - val col = q"$namingStrategy.column($paramName)" + val col = q"$namingStrategy.column($paramName)" // Resolve implicit decoders (from SqlContext) and apply ResultSet for each val d = q"implicitly[${c.prefix}.Decoder[$t]]" // Minus 1 cause Quill JDBC decoders make plus one. // ¯\_(ツ)_/¯ - val i = q"row.findColumn($col) - 1" + val i = q"row.findColumn($col) - 1" val decoderName = TermName(paramName + "Decoder") - val valueName = TermName(paramName + "Value") + val valueName = TermName(paramName + "Value") ( q"val $decoderName = $d", q"val $valueName = $decoderName($i, row)", @@ -59,8 +58,7 @@ object EntityExtractorDerivation { } resultOpt match { case Some(result) => result - case None => c.abort(c.enclosingPosition, - s"Can not derive extractor for $tpe. Constructor not found.") + case None => c.abort(c.enclosingPosition, s"Can not derive extractor for $tpe. Constructor not found.") } } q"(row: java.sql.ResultSet) => $functionBody" diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala b/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala index 3b3bbdf..d779e10 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala @@ -2,8 +2,8 @@ package xyz.driver.pdsuicommon.db import xyz.driver.pdsuicommon.domain.Id -class EntityNotFoundException private(id: String, tableName: String) - extends RuntimeException(s"Entity with id $id is not found in $tableName table") { +class EntityNotFoundException private (id: String, tableName: String) + extends RuntimeException(s"Entity with id $id is not found in $tableName table") { def this(id: Id[_], tableName: String) = this(id.toString, tableName) def this(id: Long, tableName: String) = this(id.toString, tableName) diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala b/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala index 672a34e..6b7639a 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala @@ -15,8 +15,7 @@ object MysqlQueryBuilder { nullableFields: Set[String], links: Set[TableLink], runner: Runner[T], - countRunner: CountRunner) - (implicit ec: ExecutionContext): MysqlQueryBuilder[T] = { + countRunner: CountRunner)(implicit ec: ExecutionContext): MysqlQueryBuilder[T] = { val parameters = MysqlQueryBuilderParameters( tableData = TableData(tableName, lastUpdateFieldName, nullableFields), links = links.map(x => x.foreignTableName -> x)(breakOut) @@ -28,8 +27,7 @@ object MysqlQueryBuilder { lastUpdateFieldName: Option[String], nullableFields: Set[String], links: Set[TableLink], - extractor: (ResultSet) => T) - (implicit sqlContext: SqlContext): MysqlQueryBuilder[T] = { + extractor: (ResultSet) => T)(implicit sqlContext: SqlContext): MysqlQueryBuilder[T] = { val runner = (parameters: QueryBuilderParameters) => { Future { @@ -43,14 +41,19 @@ object MysqlQueryBuilder { val countRunner = (parameters: QueryBuilderParameters) => { Future { val (sql, binder) = parameters.toSql(countQuery = true, namingStrategy = MysqlEscape) - 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 + 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 }(sqlContext.executionContext) } @@ -65,11 +68,10 @@ object MysqlQueryBuilder { } } -class MysqlQueryBuilder[T](parameters: MysqlQueryBuilderParameters) - (implicit runner: QueryBuilder.Runner[T], - countRunner: QueryBuilder.CountRunner, - ec: ExecutionContext) - extends QueryBuilder[T, MySQLDialect, MysqlEscape](parameters) { +class MysqlQueryBuilder[T](parameters: MysqlQueryBuilderParameters)(implicit runner: QueryBuilder.Runner[T], + countRunner: QueryBuilder.CountRunner, + ec: ExecutionContext) + extends QueryBuilder[T, MySQLDialect, MysqlEscape](parameters) { def withFilter(newFilter: SearchFilterExpr): QueryBuilder[T, MySQLDialect, MysqlEscape] = { new MysqlQueryBuilder[T](parameters.copy(filter = newFilter)) diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala b/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala index 9b798d8..733d355 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala @@ -32,9 +32,7 @@ object QueryBuilder { } -case class TableLink(keyColumnName: String, - foreignTableName: String, - foreignKeyColumnName: String) +case class TableLink(keyColumnName: String, foreignTableName: String, foreignKeyColumnName: String) object QueryBuilderParameters { val AllFields = Set("*") @@ -49,7 +47,7 @@ sealed trait QueryBuilderParameters { def pagination: Option[Pagination] def findLink(tableName: String): TableLink = links.get(tableName) match { - case None => throw new IllegalArgumentException(s"Cannot find a link for `$tableName`") + case None => throw new IllegalArgumentException(s"Cannot find a link for `$tableName`") case Some(link) => link } @@ -57,14 +55,12 @@ sealed trait QueryBuilderParameters { toSql(countQuery, QueryBuilderParameters.AllFields, namingStrategy) } - def toSql(countQuery: Boolean, - fields: Set[String], - namingStrategy: NamingStrategy): (String, QueryBuilder.Binder) = { + def toSql(countQuery: Boolean, fields: Set[String], namingStrategy: NamingStrategy): (String, QueryBuilder.Binder) = { val escapedTableName = namingStrategy.table(tableData.tableName) val fieldsSql: String = if (countQuery) { "count(*)" + (tableData.lastUpdateFieldName match { case Some(lastUpdateField) => s", max($escapedTableName.${namingStrategy.column(lastUpdateField)})" - case None => "" + case None => "" }) } else { if (fields == QueryBuilderParameters.AllFields) { @@ -78,7 +74,7 @@ sealed trait QueryBuilderParameters { } } val (where, bindings) = filterToSql(escapedTableName, filter, namingStrategy) - val orderBy = sortingToSql(escapedTableName, sorting, namingStrategy) + val orderBy = sortingToSql(escapedTableName, sorting, namingStrategy) val limitSql = limitToSql() @@ -92,9 +88,9 @@ sealed trait QueryBuilderParameters { import SearchFilterExpr._ def aux(expr: SearchFilterExpr): Seq[TableLink] = expr match { case Atom.TableName(tableName) => List(findLink(tableName)) - case Intersection(xs) => xs.flatMap(aux) - case Union(xs) => xs.flatMap(aux) - case _ => Nil + case Intersection(xs) => xs.flatMap(aux) + case Union(xs) => xs.flatMap(aux) + case _ => Nil } aux(filter) } @@ -188,33 +184,35 @@ sealed trait QueryBuilderParameters { // So, to handle NotEq for nullable fields we need to use more complex SQL expression. // http://dev.mysql.com/doc/refman/5.7/en/working-with-null.html val escapedColumn = escapeDimension(dimension) - val sql = s"($escapedColumn is null or $escapedColumn != ${placeholder(dimension.name)})" + val sql = s"($escapedColumn is null or $escapedColumn != ${placeholder(dimension.name)})" (sql, List(value)) case Atom.Binary(dimension, op, value) => val operator = op match { - case Eq => "=" + case Eq => "=" case NotEq => "!=" - case Like => "like" - case Gt => ">" - case GtEq => ">=" - case Lt => "<" - case LtEq => "<=" + case Like => "like" + case Gt => ">" + case GtEq => ">=" + case Lt => "<" + case LtEq => "<=" } (s"${escapeDimension(dimension)} $operator ${placeholder(dimension.name)}", List(value)) case Atom.NAry(dimension, op, values) => val sqlOp = op match { - case SearchFilterNAryOperation.In => "in" + case SearchFilterNAryOperation.In => "in" case SearchFilterNAryOperation.NotIn => "not in" } - val bindings = ListBuffer[AnyRef]() + val bindings = ListBuffer[AnyRef]() val sqlPlaceholder = placeholder(dimension.name) - val formattedValues = values.map { value => - bindings += value - sqlPlaceholder - }.mkString(", ") + val formattedValues = values + .map { value => + bindings += value + sqlPlaceholder + } + .mkString(", ") (s"${escapeDimension(dimension)} $sqlOp ($formattedValues)", bindings.toList) case Intersection(operands) => @@ -232,13 +230,11 @@ sealed trait QueryBuilderParameters { /** * @param escapedMainTableName Should be escaped */ - protected def sortingToSql(escapedMainTableName: String, - sorting: Sorting, - namingStrategy: NamingStrategy): String = { + protected def sortingToSql(escapedMainTableName: String, sorting: Sorting, namingStrategy: NamingStrategy): String = { sorting match { case Dimension(optSortingTableName, field, order) => val sortingTableName = optSortingTableName.map(namingStrategy.table).getOrElse(escapedMainTableName) - val fullName = s"$sortingTableName.${namingStrategy.column(field)}" + val fullName = s"$sortingTableName.${namingStrategy.column(field)}" s"$fullName ${orderToSql(order)}" @@ -248,14 +244,14 @@ sealed trait QueryBuilderParameters { } protected def orderToSql(x: SortingOrder): String = x match { - case Ascending => "asc" + case Ascending => "asc" case Descending => "desc" } - protected def binder(bindings: List[AnyRef]) - (bind: PreparedStatement): PreparedStatement = { - bindings.zipWithIndex.foreach { case (binding, index) => - bind.setObject(index + 1, binding) + protected def binder(bindings: List[AnyRef])(bind: PreparedStatement): PreparedStatement = { + bindings.zipWithIndex.foreach { + case (binding, index) => + bind.setObject(index + 1, binding) } bind @@ -267,7 +263,8 @@ case class PostgresQueryBuilderParameters(tableData: QueryBuilder.TableData, links: Map[String, TableLink] = Map.empty, filter: SearchFilterExpr = SearchFilterExpr.Empty, sorting: Sorting = Sorting.Empty, - pagination: Option[Pagination] = None) extends QueryBuilderParameters { + pagination: Option[Pagination] = None) + extends QueryBuilderParameters { def limitToSql(): String = { pagination.map { pagination => @@ -285,19 +282,23 @@ case class MysqlQueryBuilderParameters(tableData: QueryBuilder.TableData, links: Map[String, TableLink] = Map.empty, filter: SearchFilterExpr = SearchFilterExpr.Empty, sorting: Sorting = Sorting.Empty, - pagination: Option[Pagination] = None) extends QueryBuilderParameters { - - def limitToSql(): String = pagination.map { pagination => - val startFrom = (pagination.pageNumber - 1) * pagination.pageSize - s"limit $startFrom, ${pagination.pageSize}" - }.getOrElse("") + pagination: Option[Pagination] = None) + extends QueryBuilderParameters { + + def limitToSql(): String = + pagination + .map { pagination => + val startFrom = (pagination.pageNumber - 1) * pagination.pageSize + s"limit $startFrom, ${pagination.pageSize}" + } + .getOrElse("") } -abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameters: QueryBuilderParameters) - (implicit runner: QueryBuilder.Runner[T], - countRunner: QueryBuilder.CountRunner, - ec: ExecutionContext) { +abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameters: QueryBuilderParameters)( + implicit runner: QueryBuilder.Runner[T], + countRunner: QueryBuilder.CountRunner, + ec: ExecutionContext) { def run: Future[Seq[T]] = runner(parameters) @@ -307,11 +308,11 @@ abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameter * Runs the query and returns total found rows without considering of pagination. */ def runWithCount: Future[(Seq[T], Int, Option[LocalDateTime])] = { - val countFuture = runCount + val countFuture = runCount val selectAllFuture = run for { (total, lastUpdate) <- countFuture - all <- selectAllFuture + all <- selectAllFuture } yield (all, total, lastUpdate) } @@ -323,7 +324,6 @@ abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameter def resetFilter: QueryBuilder[T, D, N] = withFilter(SearchFilterExpr.Empty) - def withSorting(newSorting: Sorting): QueryBuilder[T, D, N] def withSorting(sorting: Option[Sorting]): QueryBuilder[T, D, N] = { @@ -332,7 +332,6 @@ abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameter def resetSorting: QueryBuilder[T, D, N] = withSorting(Sorting.Empty) - def withPagination(newPagination: Pagination): QueryBuilder[T, D, N] def withPagination(pagination: Option[Pagination]): QueryBuilder[T, D, N] = { diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala b/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala index 60db303..5144163 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala @@ -49,13 +49,13 @@ object SearchFilterExpr { object TableName { def unapply(value: Atom): Option[String] = value match { case Binary(Dimension(tableNameOpt, _), _, _) => tableNameOpt - case NAry(Dimension(tableNameOpt, _), _, _) => tableNameOpt + case NAry(Dimension(tableNameOpt, _), _, _) => tableNameOpt } } } - case class Intersection private(operands: Seq[SearchFilterExpr]) - extends SearchFilterExpr with SearchFilterExprSeqOps { + case class Intersection private (operands: Seq[SearchFilterExpr]) + extends SearchFilterExpr with SearchFilterExprSeqOps { override def replace(f: PartialFunction[SearchFilterExpr, SearchFilterExpr]): SearchFilterExpr = { if (f.isDefinedAt(this)) f(this) @@ -80,8 +80,7 @@ object SearchFilterExpr { } } - - case class Union private(operands: Seq[SearchFilterExpr]) extends SearchFilterExpr with SearchFilterExprSeqOps { + case class Union private (operands: Seq[SearchFilterExpr]) extends SearchFilterExpr with SearchFilterExprSeqOps { override def replace(f: PartialFunction[SearchFilterExpr, SearchFilterExpr]): SearchFilterExpr = { if (f.isDefinedAt(this)) f(this) @@ -123,14 +122,13 @@ object SearchFilterExpr { /** Create SearchFilterExpr with empty tableName */ def create(field: String, values: String*): SearchFilterExpr = - create(Dimension(None, field), values:_*) + create(Dimension(None, field), values: _*) /** Create SearchFilterExpr with empty tableName */ def create(field: String, values: Set[String]): SearchFilterExpr = create(Dimension(None, field), values) } - case object AllowAll extends SearchFilterExpr { override def find(p: SearchFilterExpr => Boolean): Option[SearchFilterExpr] = { if (p(this)) Some(this) @@ -159,8 +157,7 @@ object SearchFilterExpr { expr == Intersection.Empty || expr == Union.Empty } - sealed trait SearchFilterExprSeqOps { - this: SearchFilterExpr => + sealed trait SearchFilterExprSeqOps { this: SearchFilterExpr => val operands: Seq[SearchFilterExpr] @@ -171,7 +168,7 @@ object SearchFilterExpr { // Is's ok to use foldLeft. If there will be performance issues, replace it by recursive loop operands.foldLeft(Option.empty[SearchFilterExpr]) { case (None, expr) => expr.find(p) - case (x, _) => x + case (x, _) => x } } } @@ -190,13 +187,13 @@ sealed trait SearchFilterBinaryOperation object SearchFilterBinaryOperation { - case object Eq extends SearchFilterBinaryOperation + case object Eq extends SearchFilterBinaryOperation case object NotEq extends SearchFilterBinaryOperation - case object Like extends SearchFilterBinaryOperation - case object Gt extends SearchFilterBinaryOperation - case object GtEq extends SearchFilterBinaryOperation - case object Lt extends SearchFilterBinaryOperation - case object LtEq extends SearchFilterBinaryOperation + case object Like extends SearchFilterBinaryOperation + case object Gt extends SearchFilterBinaryOperation + case object GtEq extends SearchFilterBinaryOperation + case object Lt extends SearchFilterBinaryOperation + case object LtEq extends SearchFilterBinaryOperation } @@ -204,7 +201,7 @@ sealed trait SearchFilterNAryOperation object SearchFilterNAryOperation { - case object In extends SearchFilterNAryOperation + case object In extends SearchFilterNAryOperation case object NotIn extends SearchFilterNAryOperation } diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala b/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala index 4b2427c..b796b83 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala @@ -7,7 +7,7 @@ import scala.collection.generic.CanBuildFrom sealed trait SortingOrder object SortingOrder { - case object Ascending extends SortingOrder + case object Ascending extends SortingOrder case object Descending extends SortingOrder } @@ -34,25 +34,24 @@ object Sorting { def isEmpty(input: Sorting): Boolean = { input match { case Sequential(Seq()) => true - case _ => false + case _ => false } } def filter(sorting: Sorting, p: Dimension => Boolean): Seq[Dimension] = sorting match { case x: Dimension if p(x) => Seq(x) - case x: Dimension => Seq.empty - case Sequential(xs) => xs.filter(p) + case x: Dimension => Seq.empty + case Sequential(xs) => xs.filter(p) } - def collect[B, That](sorting: Sorting) - (f: PartialFunction[Dimension, B]) - (implicit bf: CanBuildFrom[Seq[Dimension], B, That]): That = sorting match { + def collect[B, That](sorting: Sorting)(f: PartialFunction[Dimension, B])( + implicit bf: CanBuildFrom[Seq[Dimension], B, That]): That = sorting match { case x: Dimension if f.isDefinedAt(x) => val r = bf.apply() r += f(x) r.result() - case x: Dimension => bf.apply().result() + case x: Dimension => bf.apply().result() case Sequential(xs) => xs.collect(f) } diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala b/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala index 5aa0084..7477e71 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala @@ -51,8 +51,7 @@ object SqlContext extends PhiLogging { } class SqlContext(dataSource: DataSource with Closeable, settings: Settings) - extends MysqlJdbcContext[MysqlEscape](dataSource) - with EntityExtractorDerivation[Literal] { + extends MysqlJdbcContext[MysqlEscape](dataSource) with EntityExtractorDerivation[Literal] { private val tpe = Executors.newFixedThreadPool(settings.threadPoolSize) @@ -77,31 +76,31 @@ class SqlContext(dataSource: DataSource with Closeable, settings: Settings) implicit override def optionDecoder[T](implicit d: Decoder[T]): Decoder[Option[T]] = decoder( sqlType = d.sqlType, - row => index => { - try { - val res = d(index - 1, row) - if (row.wasNull) { - None + row => + index => { + try { + val res = d(index - 1, row) + if (row.wasNull) { + None + } else { + Some(res) + } + } catch { + case _: NullPointerException => None + case _: IncorrectIdException => None } - else { - Some(res) - } - } catch { - case _: NullPointerException => None - case _: IncorrectIdException => None - } } ) implicit def encodeStringId[T] = MappedEncoding[StringId[T], String](_.id) implicit def decodeStringId[T] = MappedEncoding[String, StringId[T]] { case "" => throw IncorrectIdException("'' is an invalid Id value") - case x => StringId(x) + case x => StringId(x) } def decodeOptStringId[T] = MappedEncoding[Option[String], Option[StringId[T]]] { case None | Some("") => None - case Some(x) => Some(StringId(x)) + case Some(x) => Some(StringId(x)) } implicit def encodeLongId[T] = MappedEncoding[LongId[T], Long](_.id) @@ -113,21 +112,22 @@ class SqlContext(dataSource: DataSource with Closeable, settings: Settings) // TODO Dirty hack, see REP-475 def decodeOptLongId[T] = MappedEncoding[Option[Long], Option[LongId[T]]] { case None | Some(0) => None - case Some(x) => Some(LongId(x)) + case Some(x) => Some(LongId(x)) } implicit def encodeUuidId[T] = MappedEncoding[UuidId[T], String](_.toString) implicit def decodeUuidId[T] = MappedEncoding[String, UuidId[T]] { case "" => throw IncorrectIdException("'' is an invalid Id value") - case x => UuidId(x) + case x => UuidId(x) } def decodeOptUuidId[T] = MappedEncoding[Option[String], Option[UuidId[T]]] { case None | Some("") => None - case Some(x) => Some(UuidId(x)) + case Some(x) => Some(UuidId(x)) } - implicit def encodeTextJson[T: Manifest] = MappedEncoding[TextJson[T], String](x => JsonSerializer.serialize(x.content)) + implicit def encodeTextJson[T: Manifest] = + MappedEncoding[TextJson[T], String](x => JsonSerializer.serialize(x.content)) implicit def decodeTextJson[T: Manifest] = MappedEncoding[String, TextJson[T]] { x => TextJson(JsonSerializer.deserialize[T](x)) } @@ -153,14 +153,14 @@ class SqlContext(dataSource: DataSource with Closeable, settings: Settings) implicit val encodeFuzzyValue = { MappedEncoding[FuzzyValue, String] { - case FuzzyValue.No => "No" - case FuzzyValue.Yes => "Yes" + case FuzzyValue.No => "No" + case FuzzyValue.Yes => "Yes" case FuzzyValue.Maybe => "Maybe" } } implicit val decodeFuzzyValue = MappedEncoding[String, FuzzyValue] { - case "Yes" => FuzzyValue.Yes - case "No" => FuzzyValue.No + case "Yes" => FuzzyValue.Yes + case "No" => FuzzyValue.No case "Maybe" => FuzzyValue.Maybe case x => Option(x).fold { diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala b/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala index edef2eb..a3140a6 100644 --- a/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala +++ b/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala @@ -8,7 +8,7 @@ import scala.concurrent.Future trait BridgeUploadQueueRepository extends Repository { type EntityT = BridgeUploadQueue.Item - type IdT = LongId[EntityT] + type IdT = LongId[EntityT] def add(draft: EntityT): EntityT -- cgit v1.2.3