Scala ORM mit Squeryl - Eine einfache Anleitung für den Einstieg

Da mein Lieblingsprojekt (über das ich irgendwann einmal bloggen werde) dringend eine Datenbank benötigt und ich in meinem Hauptberuf genug mit Java zu tun habe, beschloss ich, es mit einem Scala ORM-Framework zu versuchen. Ich muss Sie warnen, dass ich eine Art Scala-Hacker bin. Ich missbrauche es wie eine Skriptsprache und nehme mir normalerweise ein paar Beispiele, setze sie zusammen und warte darauf, dass meine Kollegen sagen: "Das willst du nicht" oder "Du machst es falsch". Zögern Sie also nicht, mich zu korrigieren, vielleicht lerne ich ja auch noch etwas ;-)

Die Wahl des richtigen ORM-Frameworks

Ich habe nicht lange recherchiert, sondern nur ein bisschen gegoogelt. Ein Framework namens Scweery tauchte auf. Der Name Scweery klang sehr nett und es gibt einen Twitter-Account mit einem lustigen Avatar, warum also noch weiter suchen? Nun, es scheint, dass das Projekt nicht mehr so aktiv ist (seit über einem Jahr gibt es keine Updates mehr und das ist bei Scala eine lange Zeit). Schließlich kam Stackoverflow zur Rettung. Ich fand eine Frage mit dem Titel Examples of Scala database persistence. Ich entschied mich für Squeryl, die Syntax sah gut aus und es gab eine nützliche Dokumentation. Ich bin mir nicht sicher, ob ich das richtige Framework gewählt habe, aber es hat meine anfängliche Auswahl überlebt, also lassen Sie es uns herausfinden.

Einrichten der Umgebung

Für diesen Artikel gehe ich von folgenden Voraussetzungen aus: -Sie haben Version 2.9.0 von Scala installiert -Git ist auf Ihrem System -SBT ist auf der Kommandozeile verfügbar (ich habe Version 0.7.7 verwendet) Ich glaube, die obigen Links erklären alles ziemlich gut, also lassen Sie uns anfangen!

Erste Schritte

Für den Anfang habe ich das Projekt 'Minimalbeispiel' verwendet:

[bash]
git clone https://github.com/pbrant/squeryl_sbt_minimal_example
cd squeryl_sbt_minimal_example
squeryl_sbt_minimal_example>sbt
....
[info]    using ExampleProject with sbt 0.7.7 and Scala 2.9.0
squeryl_sbt_minimal_example>update
.....
squeryl_sbt_minimal_example>compile
squeryl_sbt_minimal_example>run
[/bash]

Ich habe die Scala-Version auf 2.9.0 aktualisiert. Sie können dies tun, indem Sie die Versionsnummer project/build/build.properties ändern. Für diesen Artikel spielt das keine große Rolle, aber für Ihr echtes Projekt bietet diese neuere Version eine Menge Verbesserungen. Das ging ziemlich glatt. Lassen Sie uns nun alles rausreißen und Postgres verwenden. Öffnen Sie die Datei Main.scala (/src/main/scala/code). Entfernen Sie zunächst drop, create und printDdl. Wir wollen doch nicht, dass unsere wertvolle Produktionsdatenbank zerstört wird! Für meine Datenbanktests verwende ich meine gute alte Filmdatenbank. Mit uralten Spaltennamen (auf Niederländisch) und die ID-Spalte ist ein String. Das mag wie eine schlechte Idee klingen, aber echte Datenbanken sind so und ich habe herausgefunden, dass es eine gute Möglichkeit ist, ein neues Framework zu testen.

Schema-Definition

Der erste Abschnitt, den Sie ändern müssen, ist Bibliothek erweitert Schema. Dies ist der Abschnitt, in dem die Tabellen definiert werden. Meine Tabelle heißt Filme.

[scala]
val movies = table[ Movies ]
[/scala]

Wenn ich das Beispiel ausführe (mit zusätzlichem Code, also probieren Sie es noch nicht aus), erhalte ich folgenden Fehler: org.postgresql.util.PSQLException: ERROR: relation "Movies" does not exist Es scheint, dass die Abfragen mit den Tabellennamen in Anführungszeichen ausgeführt werden, d.h. Groß- und Kleinschreibung wird beachtet. Um das Problem zu lösen, fügen Sie ("MOVIES") an die Tabellendefinition an. Jetzt können wir auch das Problem lösen, dass eine Klasse singulär ist (im Gegensatz zu einer Datenbanktabelle). Jetzt kann ich die Klasse Movie anstelle von Movies nennen:

[scala]
val movies = table[ Movie] (" MOVIES ")
[/scala]

Definition der Tabelle

Unser nächster Schritt ist die Definition der Tabelle. (Auf Niederländisch bedeutet "jaar" "Jahr" und "naam" "Name") Diesmal müssen wir Anmerkungen verwenden, um andere Spaltennamen zu verwenden (um Tippfehler und Unterstriche loszuwerden):

[scala]
class Movie(
@Column("imdb_id")
val imdbId: String,
@Column("jaar")
val year: Int,
@Column("naam_film")
val name: String,
@Column("genre")
val genres: String
)
[/scala]

Beachten Sie, dass ich val für die Spalten verwendet habe. Wenn die Spalten veränderbar sind, ist es erlaubt, var zu verwenden.

Verbinden mit Postgresql

Um eine Verbindung zu einer Postgres-Datenbank herzustellen, ersetzen Sie die H2-Abhängigkeit in /project/build/ExampleProject.scala durch

[scala]
val pg = "postgresql" % "postgresql" % "9.0-801.jdbc4"
[/scala]

Gehen Sie nun zur Hauptmethode in Main.scala und ersetzen Sie die Treiber- und Verbindungsparameter:

[scala]
Class.forName("org.postgresql.Driver");
SessionFactory.concreteFactory = Some(() =>
Session.create(
java.sql.DriverManager.getConnection("jdbc:postgresql://localhost/moviedb", "bill", "s3cr3tp455w0rdth4t15nt5053cr3t4nym0r3n0w"),
new PostgreSqlAdapter)
)
[/scala]

Auf den ersten Blick sieht es aus wie JDBC, aber die Notation Some(()=>...) ist vielleicht etwas seltsam. Dies ist ein By-Name-Parameter. Betrachten Sie ihn einfach als eine Funktion, die bei Bedarf eine Sitzung erstellt.

A select * from

Der letzte Abschnitt befasst sich mit der eigentlichen Abfrage:

[scala]
inTransaction {
val movies = from(Library.movie)(select(_))
for (movie <- movies){
println (movie.name)
}
}
[/scala]

Zum Ausführen von Abfragen benötigen Sie eine Transaktion (auch für reine Leseabfragen). Eine Transaktion ist nach der Initialisierung der SessionFactory.concreteFactory verfügbar. Um Code in einer Transaktion auszuführen, verpacken Sie ihn in einen inTransaction-Block (Sie können auch 'transaction' verwenden, dies startet immer eine neue Transaktion, inTransaction nur, wenn gerade keine Transaktion läuft).

Die erste Zeile im inTransaction-Block führt ein select * from movie aus. Scala kann ein wenig verwirrend sein, wenn Sie wie ich neu darin sind. Die Scaladocs könnten Ihnen helfen. From finden Sie hier und select hier. Die Anweisung sollte wie folgt lauten: from Library.movie wenden Sie jede Zeile auf die select-Funktion an. Der zweite Satz von Parametern für from (der so genannte Queryable) kann mit where- und order by-Klauseln erweitert werden. Weitere Informationen finden Sie auf der Seite über selects auf der Squeryl Website. Die for-Schleife gibt natürlich alle Filmnamen aus.

'Erweiterte' Abfragen

Der vorherige Absatz war nur eine einfache Abfrage, die Sie wahrscheinlich nie im wirklichen Leben ausführen werden. Lassen Sie uns also etwas Schwierigeres versuchen:

[scala]
inTransaction {
val movies = from(Library.movie)(s=>
where(s.year === 1994)
select(s) )
println(movies)
for (movie <- movies){
println (movie.name)
}
}
[/scala]

Der Operator === ist eine Methode, die zu Int hinzugefügt wird (diese Konstruktion wird 'implizit' genannt), um die eigentliche Where-Anweisung in SQL zu erstellen. Ich habe auch ein println(movies) hinzugefügt, das die eigentliche SQL-Anweisung ausgibt, sehr nützlich!

Fazit

Squeryl gefällt mir sehr gut, es war einfach einzurichten und die grundlegende Dokumentation ist ausreichend. Ein nächster Schritt ist natürlich das Einfügen und Hinzufügen weiterer Ausdrücke (und für mich der Umgang mit Postgis-Geometrieobjekten). Ich hoffe, dieser Artikel gibt Ihnen einen Anstoß.

Quellen

-Stackoverflow- Beispiele für die Persistenz von Scala-Datenbanken -Scala-Installation -Git -Sbt-Einrichtung -Scweery -Squeryl -Squeryl auf github -Squeryl google group