fix: add postgres backend

changes:
- Add postgres backend
- Modified or added table attributes.
  UpdateDate, ForeignKeys, Booleans
- Fix test for sqlite and postgres. Compare json instead the struct.

pkg/repository/db/db.go

@@ -52,6 +52,7 @@ func New(dsnURL *url.URL, flogger logger.Logger) (Database, error) {
 	// Load Queryfiles
 	queries := make(map[string]string, 0)
 	for _, asset := range AssetNames() {
+
 		if !strings.Contains(asset, dsnURL.Scheme) {
 			continue
 		}
@@ -72,17 +73,19 @@ func New(dsnURL *url.URL, flogger logger.Logger) (Database, error) {
 	)
 
 	switch dsnURL.Scheme {
-	// case "postgres":
-	// 	// postgres://[user]:[password]@[host]:[port]/[path]?[query]
-	// 	newDBO, err := sql.Open(storageEndpoint.Scheme, storageEndpoint.String())
-	// 	if err != nil {
-	// 		return nil, err
-	// 	}
+	case "postgres":
 
-	// 	return &Postgres{
-	// 		dbo:     newDBO,
-	// 		flogger: flogger,
-	// 	}, nil
+		// postgres://[user]:[password]@[host]:[port]/[path]?[query]
+		newDBO, err := sql.Open(dsnURL.Scheme, dsnURL.String())
+		if err != nil {
+			return nil, err
+		}
+
+		database = &Postgres{
+			dbo:     newDBO,
+			flogger: flogger,
+			queries: queries,
+		}
 
 	case "sqlite3":
 

pkg/repository/db/postgres.go

@@ -4,32 +4,27 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
-	"path/filepath"
+	"time"
 
 	_ "github.com/lib/pq"
-
 	"github.com/volker-raschek/flucky/pkg/types"
 	"github.com/volker-raschek/go-logger/pkg/logger"
 )
 
-var (
-	postgresAssetPath = "pkg/storage/postgres"
-)
-
 // Postgres implementation
 type Postgres struct {
 	dbo     *sql.DB
 	flogger logger.Logger
+	queries map[string]string
 }
 
 // DeleteDevices from the database
 func (postgres *Postgres) DeleteDevices(ctx context.Context, deviceIDs ...string) error {
-	asset := filepath.Join(postgresAssetPath, "deleteDevice.sql")
-	queryBytes, err := Asset(asset)
-	if err != nil {
-		return fmt.Errorf("Failed to load asset %v: %v", asset, err)
+	queryFile := "deleteDevice.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
 	}
-	query := string(queryBytes)
 
 	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: false})
 	if err != nil {
@@ -55,12 +50,11 @@ func (postgres *Postgres) DeleteDevices(ctx context.Context, deviceIDs ...string
 
 // DeleteSensors from the database
 func (postgres *Postgres) DeleteSensors(ctx context.Context, sensorIDs ...string) error {
-	asset := filepath.Join(postgresAssetPath, "deleteSensor.sql")
-	queryBytes, err := Asset(asset)
-	if err != nil {
-		return fmt.Errorf("Failed to load asset %v: %v", asset, err)
+	queryFile := "deleteSensor.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
 	}
-	query := string(queryBytes)
 
 	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: false})
 	if err != nil {
@@ -86,12 +80,11 @@ func (postgres *Postgres) DeleteSensors(ctx context.Context, sensorIDs ...string
 
 // InsertDevices into the database
 func (postgres *Postgres) InsertDevices(ctx context.Context, devices ...*types.Device) error {
-	asset := filepath.Join(postgresAssetPath, "insertDevice.sql")
-	queryBytes, err := Asset(asset)
-	if err != nil {
-		return fmt.Errorf("Failed to load asset %v: %v", asset, err)
+	queryFile := "insertDevice.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
 	}
-	query := string(queryBytes)
 
 	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: false})
 	if err != nil {
@@ -105,7 +98,7 @@ func (postgres *Postgres) InsertDevices(ctx context.Context, devices ...*types.D
 	defer stmt.Close()
 
 	for _, device := range devices {
-		_, err = stmt.Exec(&device.ID, &device.Name, &device.Location, &device.CreationDate)
+		_, err = stmt.Exec(&device.ID, &device.Name, &device.Location, &device.CreationDate, &device.UpdateDate)
 		if err != nil {
 			tx.Rollback()
 			return fmt.Errorf("Failed to execute statement: %v", err)
@@ -132,12 +125,11 @@ func (postgres *Postgres) InsertMeasuredValues(ctx context.Context, measuredValu
 	}
 
 	// General insert function
-	insert := func(tx *sql.Tx, asset string, measuredValues []*types.MeasuredValue) error {
-		queryBytes, err := Asset(asset)
-		if err != nil {
-			return fmt.Errorf("Failed to load asset %v: %v", asset, err)
+	insert := func(tx *sql.Tx, queryFile string, measuredValues []*types.MeasuredValue) error {
+		query, present := postgres.queries[queryFile]
+		if !present {
+			return fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
 		}
-		query := string(queryBytes)
 
 		stmt, err := tx.Prepare(query)
 		if err != nil {
@@ -146,7 +138,15 @@ func (postgres *Postgres) InsertMeasuredValues(ctx context.Context, measuredValu
 		defer stmt.Close()
 
 		for _, measuredValue := range measuredValues {
-			_, err := stmt.Exec(&measuredValue.ID, &measuredValue.Value, &measuredValue.SensorID, &measuredValue.CreationDate)
+			_, err := stmt.Exec(
+				&measuredValue.ID,
+				&measuredValue.Value,
+				&measuredValue.Date,
+				&measuredValue.SensorID,
+				&measuredValue.CreationDate,
+				&measuredValue.UpdateDate,
+			)
+
 			if err != nil {
 				return fmt.Errorf("Failed to execute statement: %v", err)
 			}
@@ -156,21 +156,21 @@ func (postgres *Postgres) InsertMeasuredValues(ctx context.Context, measuredValu
 	}
 
 	for measuredValueType, measuredValues := range splittedMeasuredValues {
-		var asset string
+		var queryFile string
 
 		switch measuredValueType {
 		case "humidity":
-			asset = filepath.Join(postgresAssetPath, "insertHumidity.sql")
+			queryFile = "insertHumidity.sql"
 		case "pressure":
-			asset = filepath.Join(postgresAssetPath, "insertPressure.sql")
+			queryFile = "insertPressure.sql"
 		case "temperature":
-			asset = filepath.Join(postgresAssetPath, "insertTemperature.sql")
+			queryFile = "insertTemperature.sql"
 		default:
 			tx.Rollback()
 			return fmt.Errorf("Measured value type %v not supported", measuredValueType)
 		}
 
-		err := insert(tx, asset, measuredValues)
+		err := insert(tx, queryFile, measuredValues)
 		if err != nil {
 			tx.Rollback()
 			return err
@@ -182,12 +182,11 @@ func (postgres *Postgres) InsertMeasuredValues(ctx context.Context, measuredValu
 
 // InsertSensors into the database
 func (postgres *Postgres) InsertSensors(ctx context.Context, sensors ...*types.Sensor) error {
-	asset := filepath.Join(postgresAssetPath, "insertSensor.sql")
-	queryBytes, err := Asset(asset)
-	if err != nil {
-		return fmt.Errorf("Failed to load asset %v: %v", asset, err)
+	queryFile := "insertSensor.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
 	}
-	query := string(queryBytes)
 
 	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: false})
 	if err != nil {
@@ -201,7 +200,21 @@ func (postgres *Postgres) InsertSensors(ctx context.Context, sensors ...*types.S
 	defer stmt.Close()
 
 	for _, sensor := range sensors {
-		_, err = stmt.Exec(&sensor.ID, &sensor.Name, &sensor.Location, &sensor.WireID, &sensor.I2CBus, &sensor.I2CAddress, &sensor.GPIONumber, &sensor.Model, &sensor.Enabled, &sensor.DeviceID, &sensor.CreationDate)
+		_, err = stmt.Exec(
+			&sensor.ID,
+			&sensor.Name,
+			&sensor.Location,
+			&sensor.WireID,
+			&sensor.I2CBus,
+			&sensor.I2CAddress,
+			&sensor.GPIONumber,
+			&sensor.Model,
+			&sensor.Enabled,
+			&sensor.TickDuration,
+			&sensor.DeviceID,
+			&sensor.CreationDate,
+			&sensor.UpdateDate,
+		)
 		if err != nil {
 			tx.Rollback()
 			return fmt.Errorf("Failed to execute statement: %v", err)
@@ -211,75 +224,69 @@ func (postgres *Postgres) InsertSensors(ctx context.Context, sensors ...*types.S
 	return tx.Commit()
 }
 
+// Scheme creates all required tables if not exist
+func (postgres *Postgres) Scheme(ctx context.Context) error {
+	for _, query := range []string{
+		postgres.queries["createTableDevices.sql"],
+		postgres.queries["createTableSensors.sql"],
+		postgres.queries["createTableHumidites.sql"],
+		postgres.queries["createTablePressures.sql"],
+		postgres.queries["createTableTemperatures.sql"],
+	} {
+		_, err := postgres.dbo.ExecContext(ctx, query)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // SelectDevice from database
 func (postgres *Postgres) SelectDevice(ctx context.Context, id string) (*types.Device, error) {
-	asset := filepath.Join(postgresAssetPath, "selectDevice.sql")
-	queryBytes, err := Asset(asset)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to load asset %v: %v", asset, err)
+	queryFile := "selectDevice.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
 	}
-	query := string(queryBytes)
 
 	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
 	}
 
-	stmt, err := tx.Prepare(query)
+	devices, err := postgres.selectDevices(tx, query, id)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to prepare statement: %v", err)
-	}
-	defer stmt.Close()
-
-	row := stmt.QueryRow(id)
-
-	device := new(types.Device)
-	err = row.Scan(&device.ID, &device.Name, &device.Location, &device.CreationDate)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to scan row: %v", err)
+		return nil, err
 	}
 
 	err = tx.Commit()
 	if err != nil {
-		return nil, fmt.Errorf("Failed to commit transaction: %v", err)
+		return nil, err
 	}
 
-	return device, nil
+	if len(devices) == 0 {
+		return nil, nil
+	}
+
+	return devices[0], nil
 }
 
 // SelectDevices from the database
 func (postgres *Postgres) SelectDevices(ctx context.Context) ([]*types.Device, error) {
-	asset := filepath.Join(postgresAssetPath, "selectDevices.sql")
-	queryBytes, err := Asset(asset)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to load asset %v: %v", asset, err)
+	queryFile := "selectDevices.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
 	}
-	query := string(queryBytes)
 
 	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
 	}
 
-	stmt, err := tx.Prepare(query)
+	devices, err := postgres.selectDevices(tx, query)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to prepare statement: %v", err)
-	}
-	defer stmt.Close()
-
-	rows, err := stmt.Query()
-	if err != nil {
-		return nil, fmt.Errorf("Failed to query statement: %v", err)
-	}
-
-	devices := make([]*types.Device, 0)
-	for rows.Next() {
-		device := new(types.Device)
-		err = rows.Scan(&device.ID, &device.Name, &device.Location, &device.CreationDate)
-		if err != nil {
-			return nil, fmt.Errorf("Failed to scan row: %v", err)
-		}
-		devices = append(devices, device)
+		return nil, err
 	}
 
 	err = tx.Commit()
@@ -290,32 +297,218 @@ func (postgres *Postgres) SelectDevices(ctx context.Context) ([]*types.Device, e
 	return devices, nil
 }
 
-// SelectSensor from database
-func (postgres *Postgres) SelectSensor(ctx context.Context, id string) (*types.Sensor, error) {
-	asset := filepath.Join(postgresAssetPath, "selectSensor.sql")
-	queryBytes, err := Asset(asset)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to load asset %v: %v", asset, err)
-	}
-	query := string(queryBytes)
-
-	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
-	if err != nil {
-		return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
-	}
-
+func (postgres *Postgres) selectDevices(tx *sql.Tx, query string, args ...interface{}) ([]*types.Device, error) {
 	stmt, err := tx.Prepare(query)
 	if err != nil {
 		return nil, fmt.Errorf("Failed to prepare statement: %v", err)
 	}
 	defer stmt.Close()
 
-	row := stmt.QueryRow(id)
-
-	sensor := new(types.Sensor)
-	err = row.Scan(&sensor.ID, &sensor.Name, &sensor.Location, &sensor.WireID, &sensor.I2CBus, &sensor.I2CAddress, &sensor.GPIONumber, &sensor.Model, &sensor.Enabled, &sensor.DeviceID, &sensor.CreationDate)
+	rows, err := stmt.Query(args...)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to scan row: %v", err)
+		return nil, fmt.Errorf("Failed to query statement: %v", err)
+	}
+
+	devices := make([]*types.Device, 0)
+	for rows.Next() {
+		device := new(types.Device)
+		err = rows.Scan(
+			&device.ID,
+			&device.Name,
+			&device.Location,
+			&device.CreationDate,
+			&device.UpdateDate,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("Failed to scan row: %v", err)
+		}
+		devices = append(devices, device)
+	}
+
+	return devices, nil
+}
+
+// SelectHumidity returns humidity from the database
+func (postgres *Postgres) SelectHumidity(ctx context.Context, id string) (*types.MeasuredValue, error) {
+	queryFile := "selectHumidity.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
+	}
+
+	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	if err != nil {
+		return nil, err
+	}
+
+	measuredValues, err := postgres.selectMeasuredValue(tx, query, id)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	if measuredValues == nil {
+		return nil, nil
+	}
+
+	for _, measuredValue := range measuredValues {
+		measuredValue.ValueType = "humidity"
+	}
+
+	return measuredValues[0], nil
+}
+
+// SelectHumidities returns humidities from the database
+func (postgres *Postgres) SelectHumidities(ctx context.Context) ([]*types.MeasuredValue, error) {
+	queryFile := "selectHumidities.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
+	}
+
+	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	if err != nil {
+		return nil, err
+	}
+
+	measuredValues, err := postgres.selectMeasuredValue(tx, query, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, measuredValue := range measuredValues {
+		measuredValue.ValueType = "humidity"
+	}
+
+	return measuredValues, nil
+}
+
+func (postgres *Postgres) selectMeasuredValue(tx *sql.Tx, query string, args ...interface{}) ([]*types.MeasuredValue, error) {
+	stmt, err := tx.Prepare(query)
+	if err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+	defer stmt.Close()
+
+	rows, err := stmt.Query(args...)
+	if err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+
+	measuredValues := make([]*types.MeasuredValue, 0)
+	for rows.Next() {
+		measuredValue := new(types.MeasuredValue)
+		err := rows.Scan(
+			&measuredValue.ID,
+			&measuredValue.Value,
+			&measuredValue.SensorID,
+			&measuredValue.Date,
+			&measuredValue.CreationDate,
+			&measuredValue.UpdateDate,
+		)
+
+		if err != nil {
+			tx.Rollback()
+			return nil, err
+		}
+
+		measuredValues = append(measuredValues, measuredValue)
+	}
+
+	return measuredValues, nil
+}
+
+// SelectPressure returns pressure from the database
+func (postgres *Postgres) SelectPressure(ctx context.Context, id string) (*types.MeasuredValue, error) {
+	queryFile := "selectPressure.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
+	}
+
+	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	if err != nil {
+		return nil, err
+	}
+
+	measuredValues, err := postgres.selectMeasuredValue(tx, query, id)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	if measuredValues == nil {
+		return nil, nil
+	}
+
+	for _, measuredValue := range measuredValues {
+		measuredValue.ValueType = "pressure"
+	}
+
+	return measuredValues[0], nil
+}
+
+// SelectPressures returns pressure from the database
+func (postgres *Postgres) SelectPressures(ctx context.Context) ([]*types.MeasuredValue, error) {
+	queryFile := "selectPressures.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
+	}
+
+	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	if err != nil {
+		return nil, err
+	}
+
+	measuredValues, err := postgres.selectMeasuredValue(tx, query, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, measuredValue := range measuredValues {
+		measuredValue.ValueType = "pressure"
+	}
+
+	return measuredValues, nil
+}
+
+// SelectSensor from database
+func (postgres *Postgres) SelectSensor(ctx context.Context, id string) (*types.Sensor, error) {
+	queryFile := "selectSensor.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
+	}
+
+	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	if err != nil {
+		return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
+	}
+
+	sensors, err := postgres.selectSensors(tx, query, id)
+	if err != nil {
+		return nil, err
 	}
 
 	err = tx.Commit()
@@ -323,42 +516,29 @@ func (postgres *Postgres) SelectSensor(ctx context.Context, id string) (*types.S
 		return nil, fmt.Errorf("Failed to commit transaction: %v", err)
 	}
 
-	return sensor, nil
+	if len(sensors) == 0 {
+		return nil, nil
+	}
+
+	return sensors[0], nil
 }
 
 // SelectSensors from the database
 func (postgres *Postgres) SelectSensors(ctx context.Context) ([]*types.Sensor, error) {
-	asset := filepath.Join(postgresAssetPath, "selectSensors.sql")
-	queryBytes, err := Asset(asset)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to load asset %v: %v", asset, err)
+	queryFile := "selectSensors.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
 	}
-	query := string(queryBytes)
 
 	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		return nil, fmt.Errorf("Failed to begin new transaction: %v", err)
 	}
 
-	stmt, err := tx.Prepare(query)
+	sensors, err := postgres.selectSensors(tx, query)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to prepare statement: %v", err)
-	}
-	defer stmt.Close()
-
-	rows, err := stmt.Query()
-	if err != nil {
-		return nil, fmt.Errorf("Failed to query statement: %v", err)
-	}
-
-	sensors := make([]*types.Sensor, 0)
-	for rows.Next() {
-		sensor := new(types.Sensor)
-		err = rows.Scan(&sensor.ID, &sensor.Name, &sensor.Location, &sensor.WireID, &sensor.I2CBus, &sensor.I2CAddress, &sensor.GPIONumber, &sensor.Model, &sensor.Enabled, &sensor.DeviceID, &sensor.CreationDate)
-		if err != nil {
-			return nil, fmt.Errorf("Failed to scan row: %v", err)
-		}
-		sensors = append(sensors, sensor)
+		return nil, err
 	}
 
 	err = tx.Commit()
@@ -369,12 +549,193 @@ func (postgres *Postgres) SelectSensors(ctx context.Context) ([]*types.Sensor, e
 	return sensors, nil
 }
 
+func (postgres *Postgres) selectSensors(tx *sql.Tx, query string, args ...interface{}) ([]*types.Sensor, error) {
+	stmt, err := tx.Prepare(query)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to prepare statement: %v", err)
+	}
+	defer stmt.Close()
+
+	rows, err := stmt.Query(args...)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to query statement: %v", err)
+	}
+
+	sensors := make([]*types.Sensor, 0)
+	for rows.Next() {
+		sensor := new(types.Sensor)
+		err = rows.Scan(
+			&sensor.ID,
+			&sensor.Name,
+			&sensor.Location,
+			&sensor.WireID,
+			&sensor.I2CBus,
+			&sensor.I2CAddress,
+			&sensor.GPIONumber,
+			&sensor.Model,
+			&sensor.Enabled,
+			&sensor.TickDuration,
+			&sensor.DeviceID,
+			&sensor.CreationDate,
+			&sensor.UpdateDate,
+		)
+
+		if err != nil {
+			return nil, fmt.Errorf("Failed to scan row: %v", err)
+		}
+		sensors = append(sensors, sensor)
+	}
+
+	return sensors, nil
+}
+
+// SelectTemperature returns temperatures from the database
+func (postgres *Postgres) SelectTemperature(ctx context.Context, id string) (*types.MeasuredValue, error) {
+	queryFile := "selectTemperature.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
+	}
+
+	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	if err != nil {
+		return nil, err
+	}
+
+	measuredValues, err := postgres.selectMeasuredValue(tx, query, id)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	if measuredValues == nil {
+		return nil, nil
+	}
+
+	for _, measuredValue := range measuredValues {
+		measuredValue.ValueType = "temperatures"
+	}
+
+	return measuredValues[0], nil
+}
+
+// SelectTemperatures returns temperatures from the database
+func (postgres *Postgres) SelectTemperatures(ctx context.Context) ([]*types.MeasuredValue, error) {
+	queryFile := "selectTemperatures.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return nil, fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
+	}
+
+	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	if err != nil {
+		return nil, err
+	}
+
+	measuredValues, err := postgres.selectMeasuredValue(tx, query, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, measuredValue := range measuredValues {
+		measuredValue.ValueType = "temperatures"
+	}
+
+	return measuredValues, nil
+}
+
 // UpdateDevices updates a device in the database
 func (postgres *Postgres) UpdateDevices(ctx context.Context, devices ...*types.Device) error {
-	return nil
+	queryFile := "updateDevice.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
+	}
+
+	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: false})
+	if err != nil {
+		return err
+	}
+
+	stmt, err := tx.Prepare(query)
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	defer stmt.Close()
+
+	for _, device := range devices {
+		now := time.Now()
+		device.UpdateDate = &now
+
+		_, err := stmt.Exec(
+			&device.Name,
+			&device.Location,
+			&device.CreationDate,
+			&device.UpdateDate,
+			&device.ID,
+		)
+		if err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+
+	return tx.Commit()
 }
 
 // UpdateSensors updates a sensor in the database
-func (postgres *Postgres) UpdateSensors(ctx context.Context, sensor ...*types.Sensor) error {
-	return nil
+func (postgres *Postgres) UpdateSensors(ctx context.Context, sensors ...*types.Sensor) error {
+	queryFile := "updateSensor.sql"
+	query, present := postgres.queries[queryFile]
+	if !present {
+		return fmt.Errorf("SQLite-Backend: File %v not found", queryFile)
+	}
+
+	tx, err := postgres.dbo.BeginTx(ctx, &sql.TxOptions{ReadOnly: false})
+	if err != nil {
+		return err
+	}
+
+	stmt, err := tx.Prepare(query)
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	defer stmt.Close()
+
+	for _, sensor := range sensors {
+		now := time.Now()
+		sensor.UpdateDate = &now
+		_, err := stmt.Exec(
+			&sensor.Name,
+			&sensor.Location,
+			&sensor.WireID,
+			&sensor.I2CBus,
+			&sensor.I2CAddress,
+			&sensor.GPIONumber,
+			&sensor.Model,
+			&sensor.Enabled,
+			&sensor.TickDuration,
+			&sensor.DeviceID,
+			&sensor.CreationDate,
+			&sensor.UpdateDate,
+			&sensor.ID,
+		)
+		if err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+
+	return tx.Commit()
 }

pkg/repository/db/postgres/createTableDevices.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS devices (
+  device_id               CHAR(36)                                                CONSTRAINT pk_devices PRIMARY KEY,
+  device_name             VARCHAR(64)                                             NOT NULL,
+  device_location         VARCHAR(64),
+  creation_date           TIMESTAMP                   DEFAULT CURRENT_TIMESTAMP   NOT NULL,
+  update_date             TIMESTAMP
+);

pkg/repository/db/postgres/createTableHumidities.sql

@@ -0,0 +1,14 @@
+CREATE TABLE IF NOT EXISTS humidities (
+  id                      CHAR(36)                                                CONSTRAINT pk_humidities PRIMARY KEY,
+  value                   NUMERIC(10,3)                                           NOT NULL,
+  date                    TIMESTAMP                                               NOT NULL,
+  sensor_id               CHAR(36)                                                NOT NULL,
+  creation_date           TIMESTAMP                   DEFAULT CURRENT_TIMESTAMP   NOT NULL,
+  update_date             TIMESTAMP
+);
+
+ALTER TABLE humidities
+ADD FOREIGN KEY (sensor_id)
+REFERENCES sensors(sensor_id)
+ON DELETE CASCADE
+ON UPDATE CASCADE;

pkg/repository/db/postgres/createTablePressures.sql

@@ -0,0 +1,14 @@
+CREATE TABLE IF NOT EXISTS pressures (
+  id                      CHAR(36)                                                CONSTRAINT pk_pressures PRIMARY KEY,
+  value                   NUMERIC(10,3)                                           NOT NULL,
+  date                    TIMESTAMP                                               NOT NULL,
+  sensor_id               CHAR(36)                                                NOT NULL,
+  creation_date           TIMESTAMP                   DEFAULT CURRENT_TIMESTAMP   NOT NULL,
+  update_date             TIMESTAMP
+);
+
+ALTER TABLE pressures
+ADD FOREIGN KEY (sensor_id)
+REFERENCES sensors(sensor_id)
+ON DELETE CASCADE
+ON UPDATE CASCADE;

pkg/repository/db/postgres/createTableSensors.sql

@@ -0,0 +1,21 @@
+CREATE TABLE IF NOT EXISTS sensors (
+  sensor_id               CHAR(36)                                                CONSTRAINT pk_sensors PRIMARY KEY,
+  sensor_name             VARCHAR(64)                                             NOT NULL,
+  sensor_location         VARCHAR(64),
+  wire_id                 VARCHAR(64),
+  i2c_bus                 VARCHAR(255),
+  i2c_address             VARCHAR(12),
+  gpio_number             VARCHAR(6),
+  sensor_model            VARCHAR(16)                                             NOT NULL,
+  sensor_enabled          BOOLEAN                     DEFAULT TRUE                NOT NULL,
+  tick_duration           VARCHAR(6)                                              NOT NULL,
+  device_id               CHAR(36)                                                NOT NULL,
+  creation_date           TIMESTAMP                   DEFAULT CURRENT_TIMESTAMP   NOT NULL,
+  update_date             TIMESTAMP
+);
+
+ALTER TABLE sensors
+ADD FOREIGN KEY (device_id)
+REFERENCES devices(device_id)
+ON DELETE CASCADE
+ON UPDATE CASCADE;

pkg/repository/db/postgres/createTableTemperatures.sql

@@ -0,0 +1,14 @@
+CREATE TABLE IF NOT EXISTS temperatures (
+  id                      CHAR(36)                                                CONSTRAINT pk_temperatures PRIMARY KEY,
+  value                   NUMERIC(10,3)                                           NOT NULL,
+  date                    TIMESTAMP                                               NOT NULL,
+  sensor_id               CHAR(36)                                                NOT NULL,
+  creation_date           TIMESTAMP                   DEFAULT CURRENT_TIMESTAMP   NOT NULL,
+  update_date             TIMESTAMP
+);
+
+ALTER TABLE temperatures
+ADD FOREIGN KEY (sensor_id)
+REFERENCES sensors(sensor_id)
+ON DELETE CASCADE
+ON UPDATE CASCADE;

pkg/repository/db/postgres/deleteDevice.sql

@@ -1,2 +1,2 @@
-DELETE FROM sensors
+DELETE FROM devices
 WHERE device_id = $1;

pkg/repository/db/postgres/insertDevice.sql

@@ -2,6 +2,7 @@ INSERT INTO devices (
   device_id,
   device_name,
   device_location,
-  creation_date
+  creation_date,
+  update_date
 )
-VALUES ($1, $2, $3, $4);
+VALUES ($1, $2, $3, $4, $5);

pkg/repository/db/postgres/insertHumidity.sql

@@ -1,10 +1,9 @@
 INSERT INTO humidities (
-  humidity_id,
-  humidity_value,
-  humidity_from_date,
-  humidity_till_date,
+  id,
+  value,
+  date,
   sensor_id,
   creation_date,
   update_date
 )
-VALUES ($1, $2, $3, $4, $5, $6, $7);
+VALUES ($1, $2, $3, $4, $5, $6);

pkg/repository/db/postgres/insertPressure.sql

@@ -1,10 +1,9 @@
 INSERT INTO pressures (
-  pressure_id,
-  pressure_value,
-  pressure_from_date,
-  pressure_till_date,
+  id,
+  value,
+  date,
   sensor_id,
   creation_date,
   update_date
 )
-VALUES ($1, $2, $3, $4, $5, $6, $7);
+VALUES ($1, $2, $3, $4, $5, $6);

pkg/repository/db/postgres/insertSensor.sql

@@ -8,7 +8,9 @@ INSERT INTO sensors (
   gpio_number,
   sensor_model,
   sensor_enabled,
+  tick_duration,
   device_id,
-  creation_date
+  creation_date,
+  update_date
 )
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11);
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13);

pkg/repository/db/postgres/insertTemperature.sql

@@ -1,10 +1,9 @@
 INSERT INTO temperatures (
-  temperature_id,
-  temperature_value,
-  temperature_from_date,
-  temperature_till_date,
+  id,
+  value,
+  date,
   sensor_id,
   creation_date,
   update_date
 )
-VALUES ($1, $2, $3, $4, $5, $6, $7);
+VALUES ($1, $2, $3, $4, $5, $6);

pkg/repository/db/postgres/selectDevice.sql

@@ -2,7 +2,8 @@ SELECT
   device_id,
   device_name,
   device_location,
-  creation_date
+  creation_date,
+  update_date
 FROM
   devices
 WHERE device_id = $1;

pkg/repository/db/postgres/selectDevices.sql

@@ -2,6 +2,9 @@ SELECT
   device_id,
   device_name,
   device_location,
-  creation_date
+  creation_date,
+  update_date
 FROM
-  devices;
+  devices
+ORDER BY
+  device_id ASC;

pkg/repository/db/postgres/selectHumidities.sql

@@ -0,0 +1,9 @@
+SELECT
+  id,
+  value,
+  date,
+  sensor_id,
+  creation_date,
+  update_date
+FROM
+  humidities;

pkg/repository/db/postgres/selectHumidity.sql

@@ -0,0 +1,11 @@
+SELECT
+  id,
+  value,
+  date,
+  sensor_id,
+  creation_date,
+  update_date
+FROM
+  humidities
+WHERE
+  humidity_id = $1

pkg/repository/db/postgres/selectPressure.sql

@@ -0,0 +1,11 @@
+SELECT
+  id,
+  value,
+  date,
+  sensor_id,
+  creation_date,
+  update_date
+FROM
+  pressures
+WHERE
+  pressure_id = $1

pkg/repository/db/postgres/selectPressures.sql

@@ -0,0 +1,9 @@
+SELECT
+  id,
+  value,
+  date,
+  sensor_id,
+  creation_date,
+  update_date
+FROM
+  pressures;

pkg/repository/db/postgres/selectSensor.sql

@@ -8,8 +8,10 @@ SELECT
   gpio_number,
   sensor_model,
   sensor_enabled,
+  tick_duration,
   device_id,
-  creation_date
+  creation_date,
+  update_date
 FROM
   sensors
 WHERE

pkg/repository/db/postgres/selectSensors.sql

@@ -8,7 +8,11 @@ SELECT
   gpio_number,
   sensor_model,
   sensor_enabled,
+  tick_duration,
   device_id,
-  creation_date
+  creation_date,
+  update_date
 FROM
-  sensors;
+  sensors
+ORDER BY
+  sensor_id ASC;

pkg/repository/db/postgres/selectTemperature.sql

@@ -0,0 +1,11 @@
+SELECT
+  id,
+  value,
+  date,
+  sensor_id,
+  creation_date,
+  update_date
+FROM
+  temperatures
+WHERE
+  temperature_id = $1

pkg/repository/db/postgres/selectTemperatures.sql

@@ -0,0 +1,9 @@
+SELECT
+  id,
+  value,
+  date,
+  sensor_id,
+  creation_date,
+  update_date
+FROM
+  temperatures

pkg/repository/db/postgres/updateDevice.sql

@@ -1,8 +1,8 @@
-UPDATE device
+UPDATE devices
 SET
-  device_id = $1,
-  device_name = $2,
-  device_location = $3,
-  creation_date = $4
+  device_name = $1,
+  device_location = $2,
+  creation_date = $3,
+  update_date = $4
 WHERE
-  device_id = $5,
+  device_id = $5

pkg/repository/db/postgres/updateSensor.sql

@@ -1,15 +1,16 @@
 UPDATE sensors
 SET
-  sensor_id = $1,
-  sensor_name = $2,
-  sensor_location = $3,
-  wire_id = $4,
-  i2c_bus = $5,
-  i2c_address = $6,
-  gpio_number = $7,
-  sensor_model = $8,
-  sensor_enabled = $9,
+  sensor_name = $1,
+  sensor_location = $2,
+  wire_id = $3,
+  i2c_bus = $4,
+  i2c_address = $5,
+  gpio_number = $6,
+  sensor_model = $7,
+  sensor_enabled = $8,
+  tick_duration = $9,
   device_id = $10,
-  creation_date = $11
+  creation_date = $11,
+  update_date = $12
 WHERE
-  sensor_id = $12;
+  sensor_id = $13;

pkg/repository/db/sqlite.go

@@ -97,7 +97,7 @@ func (sqlite *SQLite) InsertDevices(ctx context.Context, devices ...*types.Devic
 	defer stmt.Close()
 
 	for _, device := range devices {
-		_, err = stmt.Exec(&device.ID, &device.Name, &device.Location, &device.CreationDate)
+		_, err = stmt.Exec(&device.ID, &device.Name, &device.Location, &device.CreationDate, &device.UpdateDate)
 		if err != nil {
 			tx.Rollback()
 			return fmt.Errorf("Failed to execute statement: %v", err)
@@ -140,8 +140,8 @@ func (sqlite *SQLite) InsertMeasuredValues(ctx context.Context, measuredValues .
 			_, err := stmt.Exec(
 				&measuredValue.ID,
 				&measuredValue.Value,
-				&measuredValue.SensorID,
 				&measuredValue.Date,
+				&measuredValue.SensorID,
 				&measuredValue.CreationDate,
 				&measuredValue.UpdateDate,
 			)
@@ -212,6 +212,7 @@ func (sqlite *SQLite) InsertSensors(ctx context.Context, sensors ...*types.Senso
 			&sensor.TickDuration,
 			&sensor.DeviceID,
 			&sensor.CreationDate,
+			&sensor.UpdateDate,
 		)
 		if err != nil {
 			tx.Rollback()
@@ -315,6 +316,7 @@ func (sqlite *SQLite) selectDevices(tx *sql.Tx, query string, args ...interface{
 			&device.Name,
 			&device.Location,
 			&device.CreationDate,
+			&device.UpdateDate,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("Failed to scan row: %v", err)
@@ -574,6 +576,7 @@ func (sqlite *SQLite) selectSensors(tx *sql.Tx, query string, args ...interface{
 			&sensor.TickDuration,
 			&sensor.DeviceID,
 			&sensor.CreationDate,
+			&sensor.UpdateDate,
 		)
 
 		if err != nil {
@@ -674,6 +677,7 @@ func (sqlite *SQLite) UpdateDevices(ctx context.Context, devices ...*types.Devic
 			&device.Name,
 			&device.Location,
 			&device.CreationDate,
+			&device.UpdateDate,
 			&device.ID,
 		)
 		if err != nil {
@@ -718,6 +722,7 @@ func (sqlite *SQLite) UpdateSensors(ctx context.Context, sensors ...*types.Senso
 			&sensor.TickDuration,
 			&sensor.DeviceID,
 			&sensor.CreationDate,
+			&sensor.UpdateDate,
 			&sensor.ID,
 		)
 		if err != nil {

pkg/repository/db/sqlite3/createTableDevices.sql

@@ -1,6 +1,7 @@
 CREATE TABLE IF NOT EXISTS devices (
-  device_id               CHAR(37)                                    PRIMARY KEY,
+  device_id               CHAR(36)                                    PRIMARY KEY,
   device_name             VARCHAR(64)                                 NOT NULL,
   device_location         VARCHAR(64),
-  creation_date           TIMESTAMP       DEFAULT CURRENT_TIMESTAMP   NOT NULL
+  creation_date           TIMESTAMP       DEFAULT CURRENT_TIMESTAMP   NOT NULL,
+  update_date             TIMESTAMP
 );

pkg/repository/db/sqlite3/createTableHumidities.sql

@@ -1,8 +1,8 @@
 CREATE TABLE IF NOT EXISTS humidities (
-  id                      CHAR(37)                                    PRIMARY KEY,
+  id                      CHAR(36)                                    PRIMARY KEY,
   value                   NUMERIC(10,3)                               NOT NULL,
   date                    TIMESTAMP                                   NOT NULL,
-  sensor_id               CHAR(37)                                    NOT NULL,
+  sensor_id               CHAR(36)                                    NOT NULL,
   creation_date           TIMESTAMP       DEFAULT CURRENT_TIMESTAMP   NOT NULL,
   update_date             TIMESTAMP,
   FOREIGN KEY(sensor_id) REFERENCES sensors(sensor_id)

pkg/repository/db/sqlite3/createTablePressures.sql

@@ -1,8 +1,8 @@
 CREATE TABLE IF NOT EXISTS pressures (
-  id                      CHAR(37)                                    PRIMARY KEY,
+  id                      CHAR(36)                                    PRIMARY KEY,
   value                   NUMERIC(10,3)                               NOT NULL,
   date                    TIMESTAMP                                   NOT NULL,
-  sensor_id               CHAR(37)                                    NOT NULL,
+  sensor_id               CHAR(36)                                    NOT NULL,
   creation_date           TIMESTAMP       DEFAULT CURRENT_TIMESTAMP   NOT NULL,
   update_date             TIMESTAMP,
   FOREIGN KEY(sensor_id) REFERENCES sensors(sensor_id)

pkg/repository/db/sqlite3/createTableSensors.sql

@@ -1,5 +1,5 @@
 CREATE TABLE IF NOT EXISTS sensors (
-  sensor_id               CHAR(37)                                    PRIMARY KEY,
+  sensor_id               CHAR(36)                                    PRIMARY KEY,
   sensor_name             VARCHAR(64)                                 NOT NULL,
   sensor_location         VARCHAR(64),
   wire_id                 VARCHAR(64),
@@ -9,7 +9,8 @@ CREATE TABLE IF NOT EXISTS sensors (
   sensor_model            VARCHAR(16)                                 NOT NULL,
   sensor_enabled          INTEGER(1)      DEFAULT 1                   NOT NULL,
   tick_duration           VARCHAR(6)                                  NOT NULL,
-  device_id               CHAR(37)                                    NOT NULL,
+  device_id               CHAR(36)                                    NOT NULL,
   creation_date           TIMESTAMP       DEFAULT CURRENT_TIMESTAMP,
+  update_date             TIMESTAMP,
   FOREIGN KEY(device_id) REFERENCES devices(device_id)
 );

pkg/repository/db/sqlite3/createTableTemperatures.sql

@@ -1,8 +1,8 @@
 CREATE TABLE IF NOT EXISTS temperatures (
-  id                      CHAR(37)                                    PRIMARY KEY,
+  id                      CHAR(36)                                    PRIMARY KEY,
   value                   NUMERIC(10,3)                               NOT NULL,
   date                    TIMESTAMP                                   NOT NULL,
-  sensor_id               CHAR(37)                                    NOT NULL,
+  sensor_id               CHAR(36)                                    NOT NULL,
   creation_date           TIMESTAMP       DEFAULT CURRENT_TIMESTAMP   NOT NULL,
   update_date             TIMESTAMP,
   FOREIGN KEY(sensor_id) REFERENCES sensors(sensor_id)

pkg/repository/db/sqlite3/insertDevice.sql

@@ -2,6 +2,7 @@ INSERT INTO devices (
   device_id,
   device_name,
   device_location,
-  creation_date
+  creation_date,
+  update_date
 )
-VALUES ($1, $2, $3, $4);
+VALUES ($1, $2, $3, $4, $5);

pkg/repository/db/sqlite3/insertSensor.sql

@@ -10,6 +10,7 @@ INSERT INTO sensors (
   sensor_enabled,
   tick_duration,
   device_id,
-  creation_date
+  creation_date,
+  update_date
 )
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13);

pkg/repository/db/sqlite3/selectDevice.sql

@@ -2,7 +2,8 @@ SELECT
   device_id,
   device_name,
   device_location,
-  creation_date
+  creation_date,
+  update_date
 FROM
   devices
 WHERE device_id = $1;

pkg/repository/db/sqlite3/selectDevices.sql

@@ -2,6 +2,7 @@ SELECT
   device_id,
   device_name,
   device_location,
-  creation_date
+  creation_date,
+  update_date
 FROM
   devices;

pkg/repository/db/sqlite3/selectSensor.sql

@@ -10,7 +10,8 @@ SELECT
   sensor_enabled,
   tick_duration,
   device_id,
-  creation_date
+  creation_date,
+  update_date
 FROM
   sensors
 WHERE

pkg/repository/db/sqlite3/selectSensors.sql

@@ -10,7 +10,8 @@ SELECT
   sensor_enabled,
   tick_duration,
   device_id,
-  creation_date
+  creation_date,
+  update_date
 FROM
   sensors
 ORDER BY

pkg/repository/db/sqlite3/updateDevice.sql

@@ -2,6 +2,7 @@ UPDATE devices
 SET
   device_name = $1,
   device_location = $2,
-  creation_date = $3
+  creation_date = $3,
+  update_date = $4
 WHERE
-  device_id = $4
+  device_id = $5

pkg/repository/db/sqlite3/updateSensor.sql

@@ -10,6 +10,7 @@ SET
   sensor_enabled = $8,
   tick_duration = $9,
   device_id = $10,
-  creation_date = $11
+  creation_date = $11,
+  update_date = $12
 WHERE
-  sensor_id = $12;
+  sensor_id = $13;