756 lines
22 KiB
Java
756 lines
22 KiB
Java
package de.hsel.itech.db;
|
|
|
|
import de.hsel.itech.config.Configuration;
|
|
import de.hsel.itech.db.pojo.Author;
|
|
import de.hsel.itech.db.pojo.Book;
|
|
import de.hsel.itech.db.pojo.Category;
|
|
import de.hsel.itech.db.pojo.Publisher;
|
|
import org.jetbrains.annotations.NotNull;
|
|
import org.jetbrains.annotations.Nullable;
|
|
import org.mariadb.jdbc.MariaDbPoolDataSource;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.FileReader;
|
|
import java.io.IOException;
|
|
import java.net.URL;
|
|
import java.sql.Connection;
|
|
import java.sql.PreparedStatement;
|
|
import java.sql.ResultSet;
|
|
import java.sql.SQLException;
|
|
import java.time.Year;
|
|
import java.util.AbstractMap;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* base class for everything regarding the database.
|
|
*
|
|
* @author Johannes Theiner
|
|
* @version 0.1
|
|
* @since 0.1
|
|
*/
|
|
public class Database {
|
|
|
|
private final String book = "book";
|
|
private final String author = "author";
|
|
private final String authorBook = "author_book";
|
|
private final String publisher = "publisher";
|
|
private final String category = "category";
|
|
|
|
private static Database instance;
|
|
|
|
/**
|
|
* Singleton for database access.
|
|
*
|
|
* @return {@link Database}
|
|
*/
|
|
public static Database getInstance() {
|
|
if (instance == null)
|
|
instance = new Database();
|
|
return instance;
|
|
}
|
|
|
|
private MariaDbPoolDataSource dataSource;
|
|
|
|
/**
|
|
* initializes connection pool and executes database setup.
|
|
*/
|
|
private Database() {
|
|
Configuration config = Configuration.get();
|
|
dataSource = new MariaDbPoolDataSource("jdbc:mysql://" + config.getDatabase().getHostname()
|
|
+ ":" + config.getDatabase().getPort() + "/" + config.getDatabase().getDatabase() + "?useUnicode=true&characterEncoding=UTF-8");
|
|
try {
|
|
dataSource.setUser(config.getDatabase().getUsername());
|
|
dataSource.setPassword(config.getDatabase().getPassword());
|
|
dataSource.initialize();
|
|
|
|
Connection connection = getConnection();
|
|
assert connection != null;
|
|
URL file = getClass().getClassLoader().getResource("database.sql");
|
|
assert file != null;
|
|
try (BufferedReader br = new BufferedReader(new FileReader(file.getFile()))) {
|
|
for (String line = br.readLine(); line != null; line = br.readLine()) {
|
|
PreparedStatement statement = connection.prepareStatement(line);
|
|
statement.executeUpdate();
|
|
statement.close();
|
|
}
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
connection.close();
|
|
}
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gets connection from connection pool.
|
|
*
|
|
* @return {@link java.sql.Connection}
|
|
*/
|
|
@Nullable
|
|
private Connection getConnection() {
|
|
try {
|
|
return dataSource.getConnection();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* testing method.
|
|
*
|
|
* @return String
|
|
*/
|
|
@Deprecated
|
|
public String getHello() {
|
|
Connection connection = getConnection();
|
|
|
|
String hello = "";
|
|
try {
|
|
assert connection != null;
|
|
PreparedStatement statement = connection.prepareStatement("SELECT * FROM test WHERE id = 1");
|
|
ResultSet resultSet = statement.executeQuery();
|
|
if (resultSet.next())
|
|
hello = resultSet.getString("hello");
|
|
|
|
connection.close();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return hello;
|
|
}
|
|
|
|
/**
|
|
* gets author by id.
|
|
*
|
|
* @param id ID from database
|
|
* @return {@link de.hsel.itech.db.pojo.Author}
|
|
*/
|
|
@Nullable
|
|
public Author getAuthor(long id) {
|
|
Map.Entry<ResultSet, Connection> entry = getResultSet(id, author);
|
|
assert entry != null;
|
|
|
|
ResultSet rs = entry.getKey();
|
|
Author author = null;
|
|
try {
|
|
author = new Author(rs.getLong("id"), rs.getString("name"));
|
|
entry.getValue().close();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return author;
|
|
}
|
|
|
|
/**
|
|
* gets author by name.
|
|
*
|
|
* @param name author name
|
|
* @return {@link de.hsel.itech.db.pojo.Author}
|
|
*/
|
|
@Nullable
|
|
public Author getAuthor(String name) {
|
|
Map.Entry<ResultSet, Connection> entry = getResultSets(author, "name", name);
|
|
assert entry != null;
|
|
assert entry.getKey() != null;
|
|
|
|
Author author = null;
|
|
ResultSet rs = entry.getKey();
|
|
try {
|
|
while(rs.next()) {
|
|
System.out.println(rs.getString("name"));
|
|
}
|
|
rs.beforeFirst();
|
|
if(!rs.next()) {
|
|
System.out.println("test");
|
|
}else
|
|
author = new Author(rs.getLong("id"), rs.getString("name"));
|
|
entry.getValue().close();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
return author;
|
|
}
|
|
|
|
/**
|
|
* gets category by id.
|
|
*
|
|
* @param id ID from database
|
|
* @return {@link de.hsel.itech.db.pojo.Category}
|
|
*/
|
|
@Nullable
|
|
public Category getCategory(long id) {
|
|
Map.Entry<ResultSet, Connection> entry = getResultSet(id, category);
|
|
assert entry != null;
|
|
ResultSet rs = entry.getKey();
|
|
|
|
try {
|
|
while(rs.next()) {
|
|
System.out.println(rs.getLong("id"));
|
|
}
|
|
|
|
rs.beforeFirst();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return getCategory(entry);
|
|
}
|
|
|
|
/**
|
|
* get category by name.
|
|
*
|
|
* @param name category name
|
|
* @return {@link de.hsel.itech.db.pojo.Category}
|
|
*/
|
|
@Nullable
|
|
public Category getCategory(String name) {
|
|
Map.Entry<ResultSet, Connection> entry = getResultSets(category, "name", name);
|
|
assert entry != null;
|
|
|
|
return getCategory(entry);
|
|
}
|
|
|
|
@Nullable
|
|
private Category getCategory(@NotNull Map.Entry<ResultSet, Connection> entry) {
|
|
ResultSet rs = entry.getKey();
|
|
Category category = null;
|
|
try{
|
|
System.out.println(rs.getStatement());
|
|
while(rs.next()) {
|
|
category = new Category(rs.getLong("id"), rs.getString("name"), rs.getString("image"));
|
|
}
|
|
entry.getValue().close();
|
|
}catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return category;
|
|
}
|
|
|
|
/**
|
|
* gets publisher by id.
|
|
*
|
|
* @param id ID from database
|
|
* @return {@link de.hsel.itech.db.pojo.Publisher}
|
|
*/
|
|
@Nullable
|
|
public Publisher getPublisher(long id) {
|
|
Map.Entry<ResultSet, Connection> entry = getResultSet(id, publisher);
|
|
assert entry != null;
|
|
|
|
ResultSet rs = entry.getKey();
|
|
Publisher publisher = null;
|
|
try {
|
|
publisher = new Publisher(rs.getLong("id"), rs.getString("name"));
|
|
entry.getValue().close();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return publisher;
|
|
}
|
|
|
|
/**
|
|
* get publisher by name.
|
|
*
|
|
* @param name publisher name
|
|
* @return {@link de.hsel.itech.db.pojo.Publisher}
|
|
*/
|
|
@Nullable
|
|
public Publisher getPublisher(String name) {
|
|
Map.Entry<ResultSet, Connection> entry = getResultSets(publisher, "name", name);
|
|
assert entry != null;
|
|
assert entry.getKey() != null;
|
|
|
|
Publisher publisher = null;
|
|
ResultSet rs = entry.getKey();
|
|
try {
|
|
while(rs.next()) {
|
|
publisher = new Publisher(rs.getLong("id"), rs.getString("name"));
|
|
}
|
|
entry.getValue().close();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
return publisher;
|
|
}
|
|
|
|
/**
|
|
* gets list of author ids from database.
|
|
*
|
|
* @param id book id from database
|
|
* @return {@link java.util.List}
|
|
*/
|
|
@Nullable
|
|
private List<Integer> getAuthors(long id) {
|
|
Map.Entry<ResultSet, Connection> entry = getResultSets(id, authorBook, book);
|
|
assert entry != null;
|
|
try {
|
|
List<Integer> list = new ArrayList<>();
|
|
ResultSet rs = entry.getKey();
|
|
while (rs.next()) {
|
|
list.add(rs.getInt(author));
|
|
}
|
|
entry.getValue().close();
|
|
return list;
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* gets book by id.
|
|
*
|
|
* @param id ID from database
|
|
* @return {@link de.hsel.itech.db.pojo.Book}
|
|
*/
|
|
@Nullable
|
|
public Book getBook(long id) {
|
|
Map.Entry<ResultSet, Connection> entry = getResultSet(id, book);
|
|
assert entry != null;
|
|
|
|
ResultSet rs = entry.getKey();
|
|
Book book = null;
|
|
try {
|
|
Category category = getCategory(rs.getLong(this.category));
|
|
Publisher publisher = getPublisher(rs.getLong(this.publisher));
|
|
List<Integer> authorIds = getAuthors(id);
|
|
assert category != null;
|
|
assert publisher != null;
|
|
assert authorIds != null;
|
|
|
|
List<Author> authors = new ArrayList<>();
|
|
for (int i : authorIds) {
|
|
Author author = getAuthor(i);
|
|
assert author != null;
|
|
authors.add(author);
|
|
}
|
|
book = new Book(rs.getLong("id"), authors, publisher, category, rs.getString("title"),
|
|
Year.of(rs.getInt("year")), rs.getInt("price"), rs.getString("description"),
|
|
rs.getString("image"));
|
|
entry.getValue().close();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return book;
|
|
}
|
|
|
|
/**
|
|
* gets all books.
|
|
*
|
|
* @return {@link java.util.List}
|
|
*/
|
|
@Nullable
|
|
public List<Book> getBooks() {
|
|
Map.Entry<ResultSet, Connection> entry = getResultSets(book, "id");
|
|
assert entry != null;
|
|
|
|
List<Long> ids = new ArrayList<>();
|
|
try {
|
|
ResultSet rs = entry.getKey();
|
|
while (rs.next()) {
|
|
ids.add(rs.getLong("id"));
|
|
}
|
|
entry.getValue().close();
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
List<Book> books = new ArrayList<>();
|
|
for (long id : ids) {
|
|
books.add(getBook(id));
|
|
}
|
|
return books;
|
|
}
|
|
|
|
/**
|
|
* gets books by category.
|
|
*
|
|
* @param category category id
|
|
* @return {@link java.util.List}
|
|
*/
|
|
@Nullable
|
|
public List<Book> getBooks(long category) {
|
|
Connection connection = getConnection();
|
|
assert connection != null;
|
|
|
|
List<Book> books = new ArrayList<>();
|
|
try {
|
|
PreparedStatement statement = connection.prepareStatement("SELECT (id) FROM book WHERE category = ?");
|
|
statement.setLong(1, category);
|
|
|
|
ResultSet resultSet = statement.executeQuery();
|
|
|
|
while (resultSet.next()) {
|
|
books.add(getBook(resultSet.getLong("id")));
|
|
}
|
|
|
|
connection.close();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return books;
|
|
}
|
|
|
|
/**
|
|
* get books by category.
|
|
*
|
|
* @param category Category object
|
|
* @return {@link java.util.List}
|
|
*/
|
|
@Nullable
|
|
public List<Book> getBooks(@NotNull Category category) {
|
|
return getBooks(category.getId());
|
|
}
|
|
|
|
|
|
/**
|
|
* Inserts book into database.
|
|
* authors, publishers, and category have to exist.
|
|
*
|
|
* @param book Book
|
|
* @return insert count
|
|
*/
|
|
public int insert(@NotNull Book book) {
|
|
Connection connection = getConnection();
|
|
assert connection != null;
|
|
|
|
int insertCount = 0;
|
|
|
|
//author exists ?
|
|
List<Author> authors = new ArrayList<>();
|
|
for (Author author : book.getAuthors()) {
|
|
if (author.getId() == 0) {
|
|
Author dbAuthor = getAuthor(author.getName());
|
|
System.out.println(dbAuthor);
|
|
if (dbAuthor == null) {
|
|
insertCount += insert(author);
|
|
dbAuthor = getAuthor(author.getName());
|
|
}
|
|
authors.add(dbAuthor);
|
|
}else authors.add(author);
|
|
}
|
|
|
|
//publisher exists ?
|
|
Publisher publisher;
|
|
if(book.getPublisher().getId() == 0) {
|
|
Publisher dbPublisher = getPublisher(book.getPublisher().getName());
|
|
if(dbPublisher != null)
|
|
publisher = dbPublisher;
|
|
else {
|
|
insertCount += insert(new Publisher(book.getPublisher().getName()));
|
|
publisher = getPublisher(book.getPublisher().getName());
|
|
}
|
|
}else publisher = book.getPublisher();
|
|
|
|
//category exists ?
|
|
Category category;
|
|
if(book.getCategory().getId() == 0) {
|
|
Category dbCategory = getCategory(book.getCategory().getName());
|
|
if(dbCategory != null)
|
|
category = dbCategory;
|
|
else {
|
|
insertCount += insert(new Category(book.getCategory().getName(), book.getCategory().getImage()));
|
|
category = getCategory(book.getCategory().getName());
|
|
}
|
|
}else category = book.getCategory();
|
|
|
|
assert publisher != null;
|
|
assert category != null;
|
|
|
|
try {
|
|
PreparedStatement statement = connection.prepareStatement("INSERT INTO book(title, description, "
|
|
+ "price, year, publisher, category, image) VALUES (?, ?, ?, ?, ?, ?, ?)");
|
|
statement.setString(1, book.getTitle());
|
|
statement.setString(2, book.getDescription());
|
|
statement.setInt(3, book.getPrice());
|
|
statement.setInt(4, book.getYear().getValue());
|
|
statement.setLong(5, publisher.getId());
|
|
statement.setLong(6, category.getId());
|
|
statement.setString(7, book.getImage());
|
|
insertCount += statement.executeUpdate();
|
|
|
|
for (Author author : authors) {
|
|
PreparedStatement authorStatement = connection.prepareStatement("INSERT INTO author_book (author, book) VALUES (?, ?)");
|
|
statement.setLong(1, author.getId());
|
|
statement.setLong(2, book.getIsbn());
|
|
insertCount += authorStatement.executeUpdate();
|
|
}
|
|
|
|
connection.close();
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return insertCount;
|
|
}
|
|
|
|
/**
|
|
* inserts Category into database.
|
|
*
|
|
* @param category Category
|
|
* @return insert count
|
|
*/
|
|
public int insert(@NotNull Category category) {
|
|
Connection connection = getConnection();
|
|
assert connection != null;
|
|
|
|
int insertCount = 0;
|
|
|
|
try {
|
|
PreparedStatement statement = connection.prepareStatement("INSERT INTO category (name, image) VALUES (?, ?)");
|
|
statement.setString(1, category.getName());
|
|
statement.setString(2, category.getImage());
|
|
insertCount += statement.executeUpdate();
|
|
|
|
connection.close();
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return insertCount;
|
|
}
|
|
|
|
/**
|
|
* inserts Author.
|
|
*
|
|
* @param author Author
|
|
* @return insert count
|
|
*/
|
|
public int insert(@NotNull Author author) {
|
|
Connection connection = getConnection();
|
|
assert connection != null;
|
|
|
|
int insertCount = 0;
|
|
try {
|
|
PreparedStatement statement = connection.prepareStatement("INSERT INTO author (name) VALUES (?)");
|
|
statement.setString(1, author.getName());
|
|
|
|
insertCount += statement.executeUpdate();
|
|
|
|
connection.close();
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return insertCount;
|
|
}
|
|
|
|
/**
|
|
* inserts Publisher.
|
|
*
|
|
* @param publisher Publisher
|
|
* @return insert count
|
|
*/
|
|
public int insert(@NotNull Publisher publisher) {
|
|
Connection connection = getConnection();
|
|
assert connection != null;
|
|
|
|
int insertCount = 0;
|
|
try {
|
|
PreparedStatement statement = connection.prepareStatement("INSERT INTO publisher (name) VALUES (?)");
|
|
statement.setString(1, publisher.getName());
|
|
|
|
insertCount += statement.executeUpdate();
|
|
|
|
connection.close();
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return insertCount;
|
|
}
|
|
|
|
/**
|
|
* deletes book from database.
|
|
*
|
|
* @param id book id
|
|
* @return deletion count
|
|
*/
|
|
public int deleteBook(long id) {
|
|
int deleteCount = 0;
|
|
|
|
try {
|
|
Connection connection = getConnection();
|
|
assert connection != null;
|
|
|
|
PreparedStatement statement = connection.prepareStatement("DELETE FROM author_book WHERE book = ?");
|
|
statement.setLong(1, id);
|
|
deleteCount = +statement.executeUpdate();
|
|
|
|
connection.close();
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
|
|
deleteCount += delete(id, book);
|
|
|
|
return deleteCount;
|
|
}
|
|
|
|
/**
|
|
* deletes author from database.
|
|
*
|
|
* @param id author id
|
|
* @return deletion count
|
|
*/
|
|
public int deleteAuthor(long id) {
|
|
return delete(id, author);
|
|
}
|
|
|
|
/**
|
|
* deletes publisher from database.
|
|
*
|
|
* @param id publisher id
|
|
* @return deletion count
|
|
*/
|
|
public int deletePublisher(long id) {
|
|
return delete(id, publisher);
|
|
}
|
|
|
|
/**
|
|
* deletes category from database.
|
|
*
|
|
* @param id category count
|
|
* @return deletion count
|
|
*/
|
|
public int deleteCategory(long id) {
|
|
return delete(id, category);
|
|
}
|
|
|
|
|
|
/**
|
|
* deletes id from table.
|
|
*
|
|
* @param id database id
|
|
* @param table table name
|
|
* @return deletion count
|
|
*/
|
|
private int delete(long id, String table) {
|
|
Connection connection = getConnection();
|
|
assert connection != null;
|
|
|
|
int deleteCount = 0;
|
|
try {
|
|
PreparedStatement statement = connection.prepareStatement("DELETE FROM " + table + " WHERE id=?");
|
|
statement.setLong(1, id);
|
|
|
|
deleteCount = +statement.executeUpdate();
|
|
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return deleteCount;
|
|
}
|
|
|
|
|
|
/**
|
|
* gets specific entry from database.
|
|
*
|
|
* @param id id from database
|
|
* @param table table name
|
|
* @return {@link java.util.Map.Entry}
|
|
*/
|
|
@Nullable
|
|
private Map.Entry<ResultSet, Connection> getResultSet(long id, String table) {
|
|
Connection connection = getConnection();
|
|
try {
|
|
assert connection != null;
|
|
PreparedStatement statement = connection.prepareStatement("SELECT * FROM " + table + " WHERE id = ?");
|
|
statement.setLong(1, id);
|
|
ResultSet resultSet = statement.executeQuery();
|
|
if (resultSet.next()) {
|
|
return new AbstractMap.SimpleEntry<>(resultSet, connection);
|
|
}
|
|
return null;
|
|
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* gets specific entries from table.
|
|
*
|
|
* @param id id all entries should reference
|
|
* @param table table name
|
|
* @param column column to match
|
|
* @return {@link java.util.Map.Entry}
|
|
*/
|
|
@Nullable
|
|
private Map.Entry<ResultSet, Connection> getResultSets(long id, @NotNull String table, @NotNull String column) {
|
|
Connection connection = getConnection();
|
|
try {
|
|
assert connection != null;
|
|
PreparedStatement statement = connection.prepareStatement("SELECT * FROM " + table + " WHERE " + column + " = ?");
|
|
statement.setLong(1, id);
|
|
|
|
return getAllEntries(connection, statement);
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* gets specific entries from table.
|
|
*
|
|
* @param table table name
|
|
* @param column column to match
|
|
* @return {@link java.util.Map.Entry}
|
|
*/
|
|
@Nullable
|
|
private Map.Entry<ResultSet, Connection> getResultSets(@NotNull String table, @NotNull String column, @NotNull String value) {
|
|
Connection connection = getConnection();
|
|
try {
|
|
assert connection != null;
|
|
PreparedStatement statement = connection.prepareStatement("SELECT * FROM " + table + " WHERE " + column + " = ?");
|
|
statement.setString(1, value);
|
|
|
|
return getAllEntries(connection, statement);
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* gets all specified columns from table.
|
|
*
|
|
* @param table table name
|
|
* @param columns columns as String array
|
|
* @return {@link java.util.Map.Entry}
|
|
*/
|
|
@Nullable
|
|
private Map.Entry<ResultSet, Connection> getResultSets(@NotNull String table, @NotNull String... columns) {
|
|
Connection connection = getConnection();
|
|
try {
|
|
assert connection != null;
|
|
PreparedStatement statement = connection.prepareStatement("SELECT (" + String.join(",", columns) + ") FROM " + table);
|
|
|
|
return getAllEntries(connection, statement);
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* gets all entries contained in result set.
|
|
*
|
|
* @param connection Connection
|
|
* @param statement query statement
|
|
* @return {@link java.util.Map.Entry}
|
|
*/
|
|
@Nullable
|
|
private Map.Entry<ResultSet, Connection> getAllEntries(@NotNull Connection connection, @NotNull PreparedStatement statement) {
|
|
try {
|
|
ResultSet resultSet = statement.executeQuery();
|
|
return new AbstractMap.SimpleEntry<>(resultSet, connection);
|
|
} catch (SQLException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
} |