org.hwo.pulscounter/src/org/hwo/pulscounter/db/PulsCounterDatabase.java

package org.hwo.pulscounter.db;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.List;
import java.util.UUID;

import org.hwo.pulscounter.SnapShot;

import static org.hwo.logging.Logging.*;
import static org.hwo.logging.LogLevel.*;

public class PulsCounterDatabase {

	private Connection	dbConnection;
	
	public PulsCounterDatabase(){
		
		try {
			getClass().getClassLoader().loadClass("org.hsqldb.jdbcDriver");
			dbConnection = DriverManager.getConnection("jdbc:hsqldb:file:synololog-hsql", "SA", "");
			
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			log(ERROR,"HyperSQL Driver could not be loaded. [%s]",e.toString());
		}
		
		InputStream is = getClass().getResourceAsStream("/org/hwo/pulscounter/db/schema/schema.sql");

		if (is == null){
			log(ERROR,"Database schema file not found");
		} else {
			try {
				BufferedReader br = new BufferedReader(new InputStreamReader(is));
				
				do {
					String sql = br.readLine();
					if (sql == null){
						break;
					}
	
					sql = sql.trim();
					
					if (!sql.equals("") && !sql.startsWith("//")){
						log(sql);
						executeSimpleSQL(sql);
					}
	
				}while (true);
				
			} catch (IOException e) {
				log(e);
			}
		}
	}
	
	public void close(){
		try {
			dbConnection.close();
		} catch (SQLException e) {
			log(ERROR,"Exception while closing database: %s",e.toString());
		}
	}
	
	private ResultSet executeSimpleSQL(String query,Object... args){
		
		try {
			PreparedStatement stmt = dbConnection.prepareStatement(query);
			
			for (int i=0;i<args.length;i++){
				stmt.setObject(i+1, args[i]);
			}
			
			stmt.execute();
			
			ResultSet result = stmt.getResultSet();
			
			stmt.closeOnCompletion();
			
			return result;
			
		} catch (SQLException e) {
			log(ERROR,"SQL Statement failed: %s",query);
			log(ERROR,"Exception: %s", e.toString());
		}
		
		return null;
	}
	
	private String executeVerySimpleQuery(String query,Object... args){
		ResultSet result = executeSimpleSQL(query,args);
		if (result != null){
			try {
				if (result.next()){
					return result.getString(1);
				}
			} catch (SQLException e) {
				log(ERROR,"SQL Statement failed: %s",query);
				log(ERROR,"Exception: %s", e.toString());
			}
		}
		return null;
	}
	
	private Object executeSimpleQueryObject(String query,Object... args){
		ResultSet result = executeSimpleSQL(query,args);
		if (result != null){
			try {
				if (result.next()){
					return result.getObject(1);
				}
			} catch (SQLException e) {
				log(ERROR,"SQL Statement failed: %s",query);
				log(ERROR,"Exception: %s", e.toString());
			}
		}
		return null;
	}

	
	public String getProperty(String name){
		return executeVerySimpleQuery("SELECT value FROM props WHERE name=?", name);
	}
	public void setProperty(String name,String value){
		executeSimpleSQL("MERGE INTO props USING (VALUES(?,?)) as p(name,value) ON props.name = p.name WHEN MATCHED THEN UPDATE SET props.value = p.value WHEN NOT MATCHED THEN INSERT VALUES uuid(), p.name, p.value", name,value);
	}
	public void removeProperty(String name){
		executeSimpleSQL("DELETE FROM props WHERE props.name = ?", name);
	}
	
	public String getSchemaVersion(){
		return getProperty("db.schema.version");
	}
	
	public void storeSnapshots(SnapShot[] snapShots){
		for (SnapShot snapShot: snapShots){
			storeSnapshot(snapShot);
		}
	}
	
	private void storeSnapshot(SnapShot snapShot){
		log(INFO,"db store snapshot [%d]",snapShot.getIndex());
			
		executeVerySimpleQuery("INSERT INTO snapshots (id,device,snap_id,timestamp,counters,analogs,inputs,outputs,pullups,inverts,field0) VALUES(uuid(),?,?,?,?,?,?,?,?,?,?)",
										snapShot.getDeviceSerial(),
										snapShot.getIndex(),
										snapShot.getTimestamp(),
										snapShot.getValues(),
										snapShot.getAnalog(),
										snapShot.getInputmask(),
										snapShot.getOutputmask(),
										snapShot.getPullupmask(),
										snapShot.getInvertmask(),
										snapShot.getField0()
										);	
	}
	
	public int highestSnapShot(int deviceSerial){
		Integer ind = (Integer)executeSimpleQueryObject("SELECT max(snap_id) FROM snapshots WHERE device=? GROUP BY device", deviceSerial);
		if (ind == null){
			return -1;
		} else {
			return ind;
		}
	}

	public SnapShot[] loadSnapshots(int fromTimestamp){
		List<SnapShot> snapshots = new LinkedList<>();
		
		ResultSet result = executeSimpleSQL("SELECT id,device,snap_id,timestamp,counters,analogs,inputs,outputs,pullups,inverts,field0 FROM snapshots WHERE timestamp >= ?", fromTimestamp);
		try {
			while (result.next()){
				
				SnapShot ss = new SnapShot(result);
				snapshots.add(ss);
			}
		} catch (SQLException e) {
			log(e);
		}
		
		return snapshots.toArray(new SnapShot[0]);
	}
	
	
}