304 lines
8.3 KiB
Java
304 lines
8.3 KiB
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.Array;
|
|
import java.sql.Connection;
|
|
import java.sql.DriverManager;
|
|
import java.sql.PreparedStatement;
|
|
import java.sql.ResultSet;
|
|
import java.sql.SQLException;
|
|
import java.util.ArrayList;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
|
|
import org.hsqldb.jdbc.JDBCArrayBasic;
|
|
import org.hsqldb.types.Type;
|
|
import org.hwo.ArrayHelper;
|
|
import org.hwo.ObjectTable;
|
|
import org.hwo.ObjectTable.ObjectSet;
|
|
import org.hwo.pulscounter.PulsCounterApplication;
|
|
import org.hwo.pulscounter.SnapShot;
|
|
import org.hwo.pulscounter.simplescript.SimpleScript;
|
|
import org.hwo.sql.Schema;
|
|
|
|
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", "");
|
|
log(INFO,"HSQLDB Version: %s",dbConnection.getMetaData().getDatabaseProductVersion());
|
|
|
|
Schema schema = new Schema(dbConnection);
|
|
schema.print();
|
|
|
|
} 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);
|
|
int i = 0;
|
|
|
|
try {
|
|
for (i=0;i<args.length;i++){
|
|
if (Array.class.isInstance(args[i]))
|
|
stmt.setArray(i+1, (Array)args[i]);
|
|
else
|
|
stmt.setObject(i+1, args[i]);
|
|
}
|
|
} catch (SQLException e){
|
|
log(ERROR,"Exception while binding: %d = %s",i,args[i]);
|
|
throw e;
|
|
}
|
|
stmt.execute();
|
|
|
|
ResultSet result = stmt.getResultSet();
|
|
|
|
stmt.closeOnCompletion();
|
|
|
|
return result;
|
|
|
|
} catch (SQLException e) {
|
|
log(ERROR,"SQL Statement failed: %s",query);
|
|
log(e);
|
|
if (e.getCause() != null){
|
|
log(ERROR,"Caused-By: %s",e.getCause().toString());
|
|
e.getCause().printStackTrace();
|
|
}
|
|
|
|
}
|
|
|
|
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(e);
|
|
}
|
|
}
|
|
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(e);
|
|
}
|
|
}
|
|
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 void deleteSnapshot(SnapShot snapShot){
|
|
log(INFO,"db delete snapshot [%d]",snapShot.getIndex());
|
|
executeVerySimpleQuery("DELETE FROM snapshots WHERE device=? AND snap_id=?", snapShot.getDeviceSerial(),snapShot.getIndex());
|
|
}
|
|
|
|
|
|
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 Integer[] getKnownDevices(){
|
|
List<Integer> devices = new LinkedList<>();
|
|
|
|
ResultSet result = executeSimpleSQL("SELECT DISTINCT device FROM snapshots ORDER BY device");
|
|
try {
|
|
while (result.next()){
|
|
devices.add( result.getInt(1));
|
|
}
|
|
} catch (SQLException e) {
|
|
log(e);
|
|
}
|
|
return devices.toArray(new Integer[0]);
|
|
}
|
|
|
|
public SnapShot[] loadSnapshots(int fromTimestamp,int deviceSerial){
|
|
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 >= ? AND device = ? ORDER BY device,timestamp", fromTimestamp, deviceSerial);
|
|
try {
|
|
while (result.next()){
|
|
|
|
SnapShot ss = new SnapShot(result);
|
|
snapshots.add(ss);
|
|
}
|
|
} catch (SQLException e) {
|
|
log(e);
|
|
}
|
|
|
|
return snapshots.toArray(new SnapShot[0]);
|
|
}
|
|
|
|
public SimpleScript[] getSimpleScripts(){
|
|
ResultSet result = executeSimpleSQL("SELECT id,name,description,elements FROM scripts");
|
|
ArrayList<SimpleScript> r = new ArrayList<>();
|
|
|
|
try {
|
|
|
|
while (result.next()){
|
|
r.add(new SimpleScript(UUID.fromString(result.getString(1)), result.getString(2), result.getString(3), ArrayHelper.cast((Object[])result.getArray(4).getArray(),new Integer[0])));
|
|
}
|
|
|
|
} catch (SQLException e) {
|
|
log(e);
|
|
}
|
|
|
|
|
|
return r.toArray(new SimpleScript[0]);
|
|
}
|
|
public void removeSimpleScript(UUID id){
|
|
executeSimpleQueryObject("DELETE FROM scripts WHERE id=?", id);
|
|
}
|
|
public void storeSimpleScript(SimpleScript simpleScript){
|
|
|
|
|
|
/* executeSimpleQueryObject("MERGE INTO scripts USING (VALUES ?,?,?,?) AS ins(uid,name,desc,elements) ON scripts.id=ins.uid WHEN MATCHED THEN UPDATE SET scripts.name=ins.name,scripts.description=ins.desc,scripts.elements=ins.elements WHEN NOT MATCHED THEN INSERT (id,name,description,elements) VALUES(ins.uid,ins.name,ins.desc,ins.elements)",
|
|
simpleScript.getId().toString(),
|
|
simpleScript.getName(),
|
|
simpleScript.getDescription(),
|
|
simpleScript.getSimpleScriptElementsAsInt()
|
|
);
|
|
*/
|
|
executeSimpleSQL("DELETE FROM scripts WHERE id=?",simpleScript.getId());
|
|
executeSimpleSQL("INSERT INTO scripts VALUES(?,?,?,?)",
|
|
simpleScript.getId(),
|
|
simpleScript.getName(),
|
|
simpleScript.getDescription(),
|
|
simpleScript.getSimpleScriptElementsAsInteger()
|
|
);
|
|
|
|
}
|
|
|
|
|
|
public ObjectTable getSnapshotsAsTable(int deviceSerial){
|
|
ObjectTable ot = new ObjectTable();
|
|
|
|
for (SnapShot ss: loadSnapshots(0,deviceSerial)){
|
|
ot.add( ss.getCSVRecord(true).getValuesAsArray() );
|
|
|
|
}
|
|
return ot;
|
|
}
|
|
|
|
public void calulateTableDeltas(ObjectTable objectTable){
|
|
ObjectSet tmp = objectTable.new ObjectSet();
|
|
|
|
for (ObjectSet row: objectTable.getRows()){
|
|
for (int p=4;p<36;p++){
|
|
int i = row.getInteger(p) - tmp.getInteger(p);
|
|
tmp.set(p,row.getInteger(p));
|
|
row.set(p,i);;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|