182 lines
3.3 KiB
Go
182 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
"os"
|
|
|
|
_ "code.google.com/p/gosqlite/sqlite3" // registers sqlite
|
|
)
|
|
|
|
type Database struct {
|
|
conn *sql.DB
|
|
}
|
|
|
|
func (db *Database) Close() error {
|
|
return db.conn.Close()
|
|
}
|
|
|
|
func (db Database) GetCommand(commandStr string) (*Command, error) {
|
|
rows, err := db.conn.Query("SELECT rowid, command FROM commands WHERE command = ?;", commandStr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var (
|
|
rowid int64
|
|
command string
|
|
)
|
|
for rows.Next() {
|
|
err = rows.Scan(&rowid, &command)
|
|
if err != nil {
|
|
rows.Close()
|
|
return nil, err
|
|
}
|
|
}
|
|
rows.Close()
|
|
if rowid == 0 {
|
|
return nil, nil
|
|
}
|
|
cmd := Command{rowid: rowid, Args: command}
|
|
|
|
if rows, err = db.conn.Query("SELECT time FROM history WHERE command_id = ?;", rowid); err != nil {
|
|
return nil, err
|
|
}
|
|
for rows.Next() {
|
|
var t int64
|
|
if err = rows.Scan(&t); err != nil {
|
|
rows.Close()
|
|
return nil, err
|
|
}
|
|
cmd.Times = append(cmd.Times, t)
|
|
}
|
|
rows.Close()
|
|
|
|
return &cmd, nil
|
|
}
|
|
|
|
func (db *Database) InsertCommand(cmdTime int64, command string) error {
|
|
var (
|
|
cmd *Command
|
|
err error
|
|
)
|
|
|
|
// will be
|
|
if cmd, err = db.GetCommand(command); err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("%#v\n", cmd)
|
|
|
|
insertCommand, err := db.conn.Prepare("INSERT INTO commands (command) VALUES (?);")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
insertTime, err := db.conn.Prepare("INSERT INTO history (command_id, time) VALUES (?,?);")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
tx, err := db.conn.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var (
|
|
commandId int64
|
|
hasTime bool
|
|
)
|
|
if cmd == nil {
|
|
res, err := tx.Stmt(insertCommand).Exec(command)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
commandId, err = res.LastInsertId()
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
cmd = &Command{rowid: commandId, Args: command}
|
|
} else {
|
|
commandId = cmd.rowid
|
|
}
|
|
for i := range cmd.Times {
|
|
if cmd.Times[i] == cmdTime {
|
|
hasTime = true
|
|
}
|
|
}
|
|
if !hasTime {
|
|
if _, err = tx.Stmt(insertTime).Exec(commandId, cmdTime); err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func NewDatabase(path string) (*Database, error) {
|
|
initDb := false
|
|
|
|
stat, err := os.Stat(path)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
initDb = true
|
|
} else {
|
|
return nil, err
|
|
}
|
|
}
|
|
if stat != nil && stat.Size() == 0 {
|
|
initDb = true
|
|
}
|
|
|
|
conn, err := sql.Open("sqlite3", path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
db := &Database{conn: conn}
|
|
|
|
if initDb {
|
|
if err := initializeDatabase(db); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return db, nil
|
|
}
|
|
|
|
func initializeDatabase(db *Database) error {
|
|
if _, err := db.conn.Exec(createCommandsTable); err != nil {
|
|
return err
|
|
}
|
|
if _, err := db.conn.Exec(createHistoryTable); err != nil {
|
|
return err
|
|
}
|
|
if _, err := db.conn.Exec(createIndexes); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
//id int NOT NULL PRIMARY KEY,
|
|
createCommandsTable = `
|
|
CREATE TABLE IF NOT EXISTS commands (
|
|
command text NOT NULL
|
|
); `
|
|
//id text NOT NULL PRIMARY KEY,
|
|
createHistoryTable = `
|
|
CREATE TABLE IF NOT EXISTS history (
|
|
"command_id" int NOT NULL,
|
|
"time" bigint NOT NULL,
|
|
CONSTRAINT "command_fk" FOREIGN KEY ("command_id") REFERENCES "commands" ("id")
|
|
); `
|
|
createIndexes = `
|
|
CREATE UNIQUE INDEX IF NOT EXISTS "commands_ix" ON "commands" (command);
|
|
`
|
|
)
|