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
89
90
|
import slick.codegen.SourceCodeGenerator
import slick.{model => m}
class TypedIdSourceCodeGenerator(
singleSchemaModel: m.Model,
databaseModel: m.Model,
idType: Option[String],
manualForeignKeys: Map[(String, String), (String, String)]
) extends SourceCodeGenerator(singleSchemaModel) {
val manualReferences =
ModelTransformation.references(databaseModel, manualForeignKeys)
val modelTypeToColumnMaper = Map(
"java.util.UUID" -> "uuidKeyMapper",
"String" -> "naturalKeyMapper",
"Int" -> "serialKeyMapper",
"Long" -> "serialKeyMapper"
)
val keyReferences: Map[m.Column, m.Column] = {
val pks = databaseModel.tables
.flatMap(_.columns)
.filter(_.options.contains(slick.ast.ColumnOption.PrimaryKey))
.map(c => (c -> c))
val fks: Seq[(m.Column, m.Column)] = databaseModel.tables
.flatMap(_.foreignKeys)
.filter(_.referencedColumns.length == 1)
.filter(_.referencedColumns.forall(
_.options.contains(slick.ast.ColumnOption.PrimaryKey)))
.flatMap(fk =>
fk.referencingColumns.flatMap(from =>
fk.referencedColumns.headOption.map(to => (from -> to))))
(pks ++ fks).toMap
}
def pKeyTypeTag(columnRef: m.Column): String = {
val schemaName = columnRef.table.schema.getOrElse("`public`")
val tableName = entityName(columnRef.table.table)
s"$schemaName.$tableName"
}
def pKeyType(columnRef: m.Column): String = {
s"${idType.getOrElse("Id")}[${pKeyTypeTag(columnRef)}]"
}
class TypedIdTable(model: m.Table) extends Table(model) { table =>
override def definitions =
Seq[Def](EntityType,
PlainSqlMapper,
TableClass,
TableValue,
PrimaryKeyMapper)
class TypedIdColumn(override val model: m.Column) extends Column(model) {
override def rawType: String = {
keyReferences.get(model).fold(super.rawType)(pKeyType)
}
}
type PrimaryKeyMapper = PrimaryKeyMapperDef
def PrimaryKeyMapper = new PrimaryKeyMapper {}
class PrimaryKeyMapperDef extends TermDef {
def primaryKeyColumn: Option[Column] = {
table.model.columns
.flatMap(c => keyReferences.get(c).filter(_ == c))
.headOption
.map(c => table.columnsByName(c.name))
}
override def enabled = primaryKeyColumn.isDefined
override def doc =
s"Implicit for mapping primary key of ${tableName(table.model.name.table)} to a base column"
override def rawName = tableName(table.model.name.table) + "KeyMapper"
override def code = primaryKeyColumn.fold("") { column =>
val tpe = s"BaseColumnType[${column.rawType}]"
s"""|implicit def $name: $tpe =
|${modelTypeToColumnMaper(column.model.tpe)}[${pKeyTypeTag(
column.model)}]
|""".stripMargin.lines.mkString("").trim
}
}
}
}
|
