demo 4 initial

.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

.gitignore

+target/

.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>tietokantaesimerkit</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>

.settings/org.eclipse.core.resources.prefs

+eclipse.preferences.version=1
+encoding//src/main/java=UTF-8
+encoding//src/test/java=UTF-8
+encoding/<project>=UTF-8

.settings/org.eclipse.jdt.core.prefs

+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.release=disabled
+org.eclipse.jdt.core.compiler.source=1.8

.settings/org.eclipse.m2e.core.prefs

+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

db_generator.sql

+--create tables
+CREATE TABLE "course" (
+	"course_name"	TEXT NOT NULL,
+	"course_id"	TEXT NOT NULL,
+	"credits"	INTEGER NOT NULL,
+	PRIMARY KEY("course_id")
+);
+CREATE TABLE "student" (
+	"first_name"	TEXT NOT NULL,
+	"last_name"	TEXT NOT NULL,
+	"student_num"	INTEGER NOT NULL UNIQUE,
+	PRIMARY KEY("student_num")
+);
+CREATE TABLE "student_credit" (
+	"s_num"	INTEGER NOT NULL,
+	"c_id"	TEXT NOT NULL,
+	"grade"	INTEGER NOT NULL,
+	PRIMARY KEY("s_num","c_id"),
+	FOREIGN KEY("s_num") REFERENCES "student"("student_num") ON DELETE CASCADE,
+	FOREIGN KEY("c_id") REFERENCES "course"("course_id")
+);
+
+--Generate some students
+INSERT INTO student(first_name,last_name,student_num) VALUES ("Vilho", "Kivihalme", 12345);
+INSERT INTO student(first_name,last_name,student_num) VALUES ("Erno", "Lokkila", 223456);
+INSERT INTO student(first_name,last_name,student_num) VALUES ("Erkki", "Kaila", 666);
+INSERT INTO student(first_name,last_name,student_num) VALUES ("Mikko-Jussi", "Laakso",777);
+
+--Add some courses
+Insert INTO course(course_name,course_id,credits) VALUES ("Algorithm Design","TKO_1234",5);
+Insert INTO course(course_name,course_id,credits) VALUES ("Tietokannat 1","TKO_6556",5);
+Insert INTO course(course_name,course_id,credits) VALUES ("Tietojenkäsittelyn perusteet","TKO_7823",5);
+
+
+--add credits for students
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (666,"TKO_1234",2);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (777,"TKO_1234",3);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (666,"TKO_6556",2);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (666,"TKO_7832",2);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (12345,"TKO_1234",4);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (777,"TKO_7832",2);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (223456,"TKO_1234",4);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (223456,"TKO_7832",2);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (12345,"TKO_6556",3);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (223456,"TKO_6556",4);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (777,"TKO_6556",5);
+INSERT INTO student_credit(s_num,c_id,grade) VALUES (12345,"TKO_7832",4);
+

pom.xml

+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>demo4.esimerkit</groupId>
+  <version>0.0.1-SNAPSHOT</version>
+  <packaging>jar</packaging>
+
+  <name>tietokantaesimerkit</name>
+  <url>http://maven.apache.org</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.1</version>
+      <scope>test</scope>
+    </dependency>
+    
+	    <!-- https://mvnrepository.com/artifact/org.xerial/sqlite-jdbc -->
+
+  </dependencies>
+  <artifactId>tietokantaesimerkki</artifactId>
+</project>

src/main/java/demo4/esimerkki/Course.java

+package demo4.esimerkki;
+
+public class Course{
+
+}

src/main/java/demo4/esimerkki/DatabaseConnector.java

+package demo4.esimerkki;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import demo4.esimerkki.exceptions.CourseNotFoundException;
+import demo4.esimerkki.exceptions.DuplicateCreditException;
+import demo4.esimerkki.exceptions.StudentNotFoundExcption;
+
+public class DatabaseConnector{
+
+	private Connection c;
+
+	/**
+	 * Heittää poikkeuksen, jos tietokantaan yhdistämisessä tulee jokin ongelma.
+	 * 
+	 * @throws SQLException
+	 */
+	public DatabaseConnector() throws SQLException {
+		//
+		c = DriverManager.getConnection("jdbc:sqlite:students.db");
+	}
+
+	/**
+	 * Palauttaa kysytyn opiskelijanumeron haltijan kokonaispistemäärän. <br>
+	 * <br>
+	 * Pohdintaa: Poikkeus heitetään, koska se signaloi kätevästi epänormaalin
+	 * tilan. Jos kysely suoritetaan opiskelijanumerolla jota ei ole, palautuisi
+	 * nolla. Mutta miten tämä eroaa tilanteesta, jossa opiskelijanumero on
+	 * olemassa, mutta suorituksia ei vielä ole kertynyt, kuten ensimmäisen vuoden
+	 * syksyn alussa? Toki tilanteessa, jossa opiskelijaa ei ole,voisi palauttaa -1,
+	 * mutta käyttämällä poikkeusta, saadaan tämän metodin käyttäjä "pakotettua"
+	 * reagoimaan poikkeavaan tilanteeseen
+	 *
+	 * 
+	 * @param studentNum tarkistettava opiskelijanumero
+	 * @return kyseisen opiskelijan kokonaisopintopistekertymä
+	 * @throws StudentNotFoundExcption jos opiskelijaa ei ole
+	 * @throws SQLException            jos tietokannassa on jotain muuta vikaa,
+	 *                                 kuten yhteysongelma tai rakenteellinen
+	 *                                 ongelma
+	 */
+	public int getTotalCredits(int studentNum) throws StudentNotFoundExcption, SQLException {
+
+		if (!studentExists(studentNum)) {
+			throw new StudentNotFoundExcption("Invalid student number:" + studentNum);
+		}
+
+		String sql = "SELECT credits FROM student_credit,course WHERE course_id==c_id AND s_num ==?";
+
+		try (PreparedStatement ps = c.prepareStatement(sql)) {
+
+			ps.setInt(1, studentNum);
+
+			ResultSet r = ps.executeQuery();
+			int sum = 0;
+			while (r.next()) {
+				sum += r.getInt(1);
+			}
+			return sum;
+		}
+
+	}
+
+	/**
+	 * Tarkistaa, onko kyseinen opiskelija tallennettu tietokantaan.
+	 * 
+	 * @param student
+	 * @return
+	 * @throws SQLException
+	 */
+	private boolean studentExists(int student) throws SQLException {
+		String sql = "SELECT * FROM student WHERE student_num ==?";
+
+		try (PreparedStatement ps = c.prepareStatement(sql)) {
+			ps.setInt(1, student);
+			ResultSet results = ps.executeQuery();
+			return results.next();
+
+		}
+	}
+
+	public void addCredit(int student_num, String course_id, int grade)
+			throws SQLException, StudentNotFoundExcption, CourseNotFoundException, DuplicateCreditException {
+
+		if (!studentExists(student_num)) {
+			throw new StudentNotFoundExcption("Student does not exist!");
+		}
+		if (!courseExists(course_id)) {
+			throw new CourseNotFoundException("Course does not exist!");
+		}
+		if (hasGrade(student_num, course_id)) {
+			throw new DuplicateCreditException("Student " + student_num + " already has grade for " + course_id);
+		}
+
+		String sql = "INSERT INTO student_credit (s_num,c_id,grade) VALUES (?,?,?);";
+
+		try (PreparedStatement ps = c.prepareStatement(sql)) {
+			ps.setInt(1, student_num);
+			ps.setString(2, course_id);
+			ps.setInt(3, grade);
+			ps.execute();
+		}
+
+	}
+
+	private boolean hasGrade(int student_num, String course_id) throws SQLException {
+		String sql = "SELECT * FROM student_credit WHERE c_id ==? AND s_num=?";
+
+		try (PreparedStatement ps = c.prepareStatement(sql)) {
+			ps.setString(1, course_id);
+			ps.setInt(2, student_num);
+			ResultSet results = ps.executeQuery();
+			return results.next();
+
+		}
+	}
+
+	private boolean courseExists(String course_id) throws SQLException {
+		String sql = "SELECT * FROM course WHERE course_id ==?";
+
+		try (PreparedStatement ps = c.prepareStatement(sql)) {
+			ps.setString(1, course_id);
+			ResultSet results = ps.executeQuery();
+			return results.next();
+		}
+	}
+
+}

src/main/java/demo4/esimerkki/StudentDatabase.java

+package demo4.esimerkki;
+
+import java.sql.SQLException;
+
+public class StudentDatabase{
+	public static void main(String[] args) {
+		DatabaseConnector db = null;
+		try {
+			db = new DatabaseConnector();
+
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		/*
+		 * Tässä näyttäisi olevan käännösvirhe: Jos käyt katsomassa getTotalCredits
+		 * -metodia, sen signatuurissa on throws -määrittely. Tämä tarkoittaa tietenkin,
+		 * että metodi heittää poikkeuksen. Poikkeus pitää käsitellä. Huomaa, että
+		 * poikkeuksia on useita. Tee siis useita peräkkäisiä catch -lohkoja, jotta voit
+		 * käsitellä kaikki poikkeukset eri tavalla.
+		 * 
+		 * Voit myös käsitellä useampia poikkeuksia samassa
+		 */
+		int totalCredits = -1;
+
+		totalCredits = db.getTotalCredits(666);
+
+		db.addCredit(666, "TKO_6556", 3);
+
+	}
+}

src/main/java/demo4/esimerkki/exceptions/CourseNotFoundException.java

+package demo4.esimerkki.exceptions;
+
+public class CourseNotFoundException extends Exception{
+
+	public CourseNotFoundException(String string) {
+		super(string);
+	}
+
+}

src/main/java/demo4/esimerkki/exceptions/DuplicateCreditException.java

+package demo4.esimerkki.exceptions;
+
+public class DuplicateCreditException extends Exception{
+
+	public DuplicateCreditException(String string) {
+		super(string);
+	}
+
+}

src/main/java/demo4/esimerkki/exceptions/StudentNotFoundExcption.java

+package demo4.esimerkki.exceptions;
+
+public class StudentNotFoundExcption extends Exception{
+
+	public StudentNotFoundExcption(String string) {
+		super(string);
+	}
+
+}