Skip to content

Commit 503cb70

Browse files
albertprzalbertprz
committed
Formatting dependent on Scala 2 / 3
1 parent a7b5707 commit 503cb70

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

42 files changed

+2090
-1657
lines changed

‎.scalafmt.conf

+16
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,22 @@
11
version = "3.8.6"
22

33
runner.dialect = scala3
4+
5+
fileOverride {
6+
"glob:**/src/main/scala-2/**" {
7+
runner.dialect = scala213
8+
}
9+
"glob:**/src/it/scala/**" {
10+
runner.dialect = scala213
11+
}
12+
"glob:**/src/test/scala/**" {
13+
runner.dialect = scala213
14+
}
15+
"glob:**/macros/src/main/scala-2/**" {
16+
runner.dialect = scala213
17+
}
18+
}
19+
420
maxColumn = 80
521

622
align.preset = more

‎core/src/main/scala/DeleteStatement.scala

+7-8
Original file line numberDiff line numberDiff line change
@@ -4,26 +4,25 @@ import com.albertprz.logograph.config.LogographConfig
44
import com.albertprz.logograph.utils
55
import utils.StringUtils.*
66

7-
case class DeleteStatement [T <: DbTable] (sqlTemplate: String,
8-
params: Map[String, Any] = Map.empty)
9-
extends SQLStatefulStatement:
7+
case class DeleteStatement[T <: DbTable](
8+
sqlTemplate: String,
9+
params: Map[String, Any] = Map.empty
10+
) extends SQLStatefulStatement:
1011

1112
lazy val (sql, paramList) = DeleteStatement.generate(this)
1213

13-
def run [F[+_]] () (using context: LogographContext[F]) =
14-
context.run(this)
14+
def run[F[+_]]()(using context: LogographContext[F]) = context.run(this)
1515

16-
override def toString () =
16+
override def toString() =
1717
s"Delete Statement: \n\n$sqlTemplate \n\nParams: \n\n${pprint(params)}\n\n"
1818

19-
2019
object DeleteStatement:
2120

2221
import SQLStatement.*
2322

2423
given LogographConfig = LogographConfig.get
2524

26-
def generate [T <: DbTable] (delete: DeleteStatement[T]) =
25+
def generate[T <: DbTable](delete: DeleteStatement[T]) =
2726

2827
val sql = getSQL(delete.sqlTemplate, delete.params)
2928
val paramList = getParamList(delete.params)

‎core/src/main/scala/InsertStatement.scala

+39-27
Original file line numberDiff line numberDiff line change
@@ -1,65 +1,77 @@
11
package com.albertprz.logograph
22

3-
43
import com.albertprz.logograph.config.LogographConfig
5-
import com.albertprz.logograph.core.{Table, Column}
4+
import com.albertprz.logograph.core.{Column, Table}
65
import com.albertprz.logograph.utils
76
import utils.StringUtils.*
87
import utils.TypeInfo
98

10-
11-
case class InsertStatement [T <: DbTable] (data: Either[Seq[T], SelectStatement[T]], typeInfo: TypeInfo)
12-
extends SQLStatefulStatement:
9+
case class InsertStatement[T <: DbTable](
10+
data: Either[Seq[T], SelectStatement[T]],
11+
typeInfo: TypeInfo
12+
) extends SQLStatefulStatement:
1313

1414
lazy val (sql, paramList) = InsertStatement.generate(this)
1515

16-
def run [F[+_]] () (using context: LogographContext[F]) =
17-
context.run(this)
16+
def run[F[+_]]()(using context: LogographContext[F]) = context.run(this)
1817

19-
override def toString () =
18+
override def toString() =
2019
data match
21-
case Left(data) => s"""Insert Statement: \n\n${sql.substring(0, sql.indexOf("?)")) + "?)"}\n\n"""
22-
case Right(query) => s"""Insert Statement: \n\n$sql \n\nParams: \n\n${pprint(query.paramList)}\n\n"""
23-
20+
case Left(data) =>
21+
s"""Insert Statement: \n\n${sql.substring(
22+
0,
23+
sql.indexOf("?)")
24+
) + "?)"}\n\n"""
25+
case Right(query) =>
26+
s"""Insert Statement: \n\n$sql \n\nParams: \n\n${pprint(
27+
query.paramList
28+
)}\n\n"""
2429

2530
object InsertStatement:
2631

2732
given LogographConfig = LogographConfig.get
2833

29-
def generate [T <: DbTable] (insert: InsertStatement[T]) =
34+
def generate[T <: DbTable](insert: InsertStatement[T]) =
3035

3136
import insert.{data, typeInfo}
3237

33-
val sql = insert.data match
34-
case Left(data) => getSQL(data, typeInfo)
35-
case Right(query) => getSQL(query, typeInfo)
38+
val sql =
39+
insert.data match
40+
case Left(data) => getSQL(data, typeInfo)
41+
case Right(query) => getSQL(query, typeInfo)
3642

37-
val paramList = insert.data match
38-
case Left(data) => data.flatMap(_.productIterator).toList
39-
case Right(query) => query.paramList
43+
val paramList =
44+
insert.data match
45+
case Left(data) => data.flatMap(_.productIterator).toList
46+
case Right(query) => query.paramList
4047

4148
(sql, paramList)
4249

43-
44-
def getSQL [T <: DbTable] (data: Seq[T], typeInfo: TypeInfo) =
50+
def getSQL[T <: DbTable](data: Seq[T], typeInfo: TypeInfo) =
4551

4652
val tableName = typeInfo.className
4753
val table = Table(tableName)
4854

4955
val elemNames = typeInfo.elemNames
50-
val paramPlaceholders = (0 to data.size - 1).map(x => elemNames.map(x => "?"))
51-
.map(stringify)
52-
.mkString(", \n")
53-
54-
s"""|INSERT INTO ${table.sql} ${stringify(elemNames.map(Column(_, tableName).sql))}
56+
val paramPlaceholders =
57+
(0 to data.size - 1)
58+
.map(x => elemNames.map(x => "?"))
59+
.map(stringify)
60+
.mkString(", \n")
61+
62+
s"""|INSERT INTO ${table.sql} ${stringify(
63+
elemNames.map(Column(_, tableName).sql)
64+
)}
5565
|VALUES $paramPlaceholders """.stripMargin
5666

57-
def getSQL [T <: DbTable] (query: SelectStatement[T], typeInfo: TypeInfo) =
67+
def getSQL[T <: DbTable](query: SelectStatement[T], typeInfo: TypeInfo) =
5868

5969
val tableName = typeInfo.className
6070
val table = Table(tableName)
6171

6272
val elemNames = typeInfo.elemNames
6373

64-
s"""|INSERT INTO ${table.sql} ${stringify(elemNames.map(Column(_, tableName).sql))}
74+
s"""|INSERT INTO ${table.sql} ${stringify(
75+
elemNames.map(Column(_, tableName).sql)
76+
)}
6577
|${query.sql} """.stripMargin

‎core/src/main/scala/LogographContext.scala

+53-44
Original file line numberDiff line numberDiff line change
@@ -1,73 +1,82 @@
11
package com.albertprz.logograph
22

3-
import java.sql.{Connection, ResultSet, PreparedStatement, Statement, Date, Time}
3+
import java.sql.{
4+
Connection,
5+
Date,
6+
PreparedStatement,
7+
ResultSet,
8+
Statement,
9+
Time
10+
}
411
import java.math.BigDecimal
5-
import scala.util.{Try, Success, Failure}
12+
import scala.util.{Failure, Success, Try}
613
import scala.collection.mutable.ListBuffer
714
import cats.Monad
815
import cats.syntax.all.*
9-
import cats.effect.{Sync, Resource}
16+
import cats.effect.{Resource, Sync}
1017

1118
import com.albertprz.logograph.config.LogographConfig
1219
import utils.TypeInfo
1320
import utils.StringUtils.*
1421
import utils.Error.{InvalidParameterType, InvalidQueryResultType}
1522
import java.lang.reflect.Method
1623

17-
18-
class LogographContext [F[_] : Sync : Monad] (conn: Connection):
24+
class LogographContext[F[_]: Sync: Monad](conn: Connection):
1925

2026
import LogographContext.*
2127

2228
conn.setAutoCommit(false)
2329

24-
def run [T <: DbDataSet] (query: SelectStatement[T]): F[List[T]] =
25-
runQuery (query)
26-
27-
def run (stmts: SQLStatefulStatement*): F[Unit] =
28-
runStatefulStatement (stmts)
30+
def run[T <: DbDataSet](query: SelectStatement[T]): F[List[T]] =
31+
runQuery(query)
2932

33+
def run(stmts: SQLStatefulStatement*): F[Unit] = runStatefulStatement(stmts)
3034

31-
private def runQuery [T <: DbDataSet] (query: SelectStatement[T]): F[List[T]] =
35+
private def runQuery[T <: DbDataSet](query: SelectStatement[T]): F[List[T]] =
3236
prepareStatement(query.sql, query.paramList).use { stmt =>
33-
34-
for resultSet <- Sync[F].blocking { stmt.executeQuery() }
35-
yield extractResults(resultSet, query.typeInfo)
37+
for resultSet <-
38+
Sync[F].blocking {
39+
stmt.executeQuery()
40+
}
41+
yield extractResults(resultSet, query.typeInfo)
3642
}
3743

38-
private def runStatefulStatement (stmts: Seq[SQLStatefulStatement]) =
44+
private def runStatefulStatement(stmts: Seq[SQLStatefulStatement]) =
3945

40-
val preparedStmts = for (sql, paramList) <- stmts.map(x => (x.sql, x.paramList))
41-
yield prepareStatement(sql, paramList)
42-
.use { stmt => Sync[F].blocking { stmt.executeUpdate() } }
46+
val preparedStmts =
47+
for (sql, paramList) <- stmts.map(x => (x.sql, x.paramList))
48+
yield prepareStatement(sql, paramList)
49+
.use(stmt => Sync[F].blocking(stmt.executeUpdate()))
4350

44-
preparedStmts.fold (Sync[F].pure(0)) { (acc, curr) => acc *> curr } *>
45-
Sync[F].blocking { conn.commit() }
46-
47-
private def prepareStatement (querySql: String, paramList: List[?]) =
48-
Resource.make { Sync[F].blocking { conn.prepareStatement(querySql) } }
49-
{ stmt => Sync[F].blocking { stmt.close() } }
50-
.map { stmt => parameteriseStatement(stmt, paramList) }
51+
preparedStmts.fold(Sync[F].pure(0))((acc, curr) => acc *> curr) *>
52+
Sync[F].blocking(conn.commit())
5153

54+
private def prepareStatement(querySql: String, paramList: List[?]) =
55+
Resource
56+
.make(Sync[F].blocking(conn.prepareStatement(querySql))) { stmt =>
57+
Sync[F].blocking(stmt.close())
58+
}
59+
.map(stmt => parameteriseStatement(stmt, paramList))
5260

5361
private object LogographContext:
5462

55-
def extractResults [T <: DbDataSet] (resultSet: ResultSet, typeInfo: TypeInfo) =
63+
def extractResults[T <: DbDataSet](resultSet: ResultSet, typeInfo: TypeInfo) =
5664

5765
val results = ListBuffer[T]()
5866

59-
val constructor = Class.forName(typeInfo.fullClassName)
60-
.getConstructors()
61-
.head
62-
67+
val constructor =
68+
Class
69+
.forName(typeInfo.fullClassName)
70+
.getConstructors()
71+
.head
6372

6473
while resultSet.next() do
6574
val ctorArgs = getCtorArgs(resultSet, typeInfo.elemTypes)
66-
results += constructor.newInstance(ctorArgs: _*).asInstanceOf[T]
75+
results += constructor.newInstance(ctorArgs*).asInstanceOf[T]
6776

6877
results.toList
6978

70-
def parameteriseStatement (stmt: PreparedStatement, params: List[?]) =
79+
def parameteriseStatement(stmt: PreparedStatement, params: List[?]) =
7180

7281
for i <- 0 to params.size - 1 do
7382
params(i) match
@@ -83,17 +92,17 @@ private object LogographContext:
8392
case other @ _ => throw InvalidParameterType(other)
8493
stmt
8594

86-
def getCtorArgs (resultSet: ResultSet, paramTypes: List[String]) =
95+
def getCtorArgs(resultSet: ResultSet, paramTypes: List[String]) =
8796

8897
for i <- 0 to paramTypes.size - 1
89-
yield paramTypes(i) match
90-
case "Int" => resultSet.getInt(i + 1)
91-
case "Long" => resultSet.getLong(i + 1)
92-
case "Float" => resultSet.getFloat(i + 1)
93-
case "Double" => resultSet.getDouble(i + 1)
94-
case "Boolean" => resultSet.getBoolean(i + 1)
95-
case "String" => resultSet.getString(i + 1)
96-
case "BigDecimal" => resultSet.getBigDecimal(i + 1)
97-
case "date" => resultSet.getDate(i + 1)
98-
case "time" => resultSet.getTime(i + 1)
99-
case other @ _ => throw InvalidQueryResultType(other)
98+
yield paramTypes(i) match
99+
case "Int" => resultSet.getInt(i + 1)
100+
case "Long" => resultSet.getLong(i + 1)
101+
case "Float" => resultSet.getFloat(i + 1)
102+
case "Double" => resultSet.getDouble(i + 1)
103+
case "Boolean" => resultSet.getBoolean(i + 1)
104+
case "String" => resultSet.getString(i + 1)
105+
case "BigDecimal" => resultSet.getBigDecimal(i + 1)
106+
case "date" => resultSet.getDate(i + 1)
107+
case "time" => resultSet.getTime(i + 1)
108+
case other @ _ => throw InvalidQueryResultType(other)

‎core/src/main/scala/SQLEngine.scala

+9-3
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,8 @@
11
package com.albertprz.logograph.core
22

3-
import com.albertprz.logograph.utils.StringUtils._
3+
import com.albertprz.logograph.utils.StringUtils.*
44
import com.albertprz.logograph.utils.Error.CaseNotAllowed
55

6-
76
enum SQLEngine:
87
case PostgreSQL, SQLServer, Oracle, SQLite, MySQL
98

@@ -16,4 +15,11 @@ object SQLEngine:
1615
case "oracle" => Right(Oracle)
1716
case "sqlite" => Right(SQLite)
1817
case "mysql" => Right(MySQL)
19-
case _ => Left(CaseNotAllowed(engineName, SQLEngine.toString(), SQLEngine.values.toSet))
18+
case _ =>
19+
Left(
20+
CaseNotAllowed(
21+
engineName,
22+
SQLEngine.toString(),
23+
SQLEngine.values.toSet
24+
)
25+
)

0 commit comments

Comments
 (0)