You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
748 lines
19 KiB
Go
748 lines
19 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"database/sql/driver"
|
|
"fmt"
|
|
"github.com/andrew-d/go-termutil"
|
|
"github.com/mgutz/ansi"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"text/tabwriter"
|
|
"time"
|
|
)
|
|
|
|
// Attr holds the data fetched from a row
|
|
// Only 1 ValueXxx field should have value, the others should be nil
|
|
type Attr struct {
|
|
// Meta
|
|
ID sql.NullInt64
|
|
ParentID sql.NullInt64
|
|
Name sql.NullString
|
|
Alias sql.NullString
|
|
Path sql.NullString
|
|
Frequency sql.NullInt64
|
|
Mark sql.NullInt64
|
|
|
|
// Values
|
|
ValueText sql.NullString
|
|
ValueBlob []byte
|
|
ValueInt sql.NullInt64
|
|
ValueReal sql.NullFloat64
|
|
ValueTime time.Time
|
|
|
|
// Timestamps
|
|
CreatedAt NullTime
|
|
UpdatedAt NullTime
|
|
AccessedAt NullTime
|
|
DeletedAt NullTime
|
|
}
|
|
|
|
const sqlSelect = "id, value_text, name, parent_id, alias, mark, value_blob, created_at, updated_at"
|
|
|
|
// GetID returns the int64 value of attr's ID.
|
|
func (attr Attr) GetID() int64 {
|
|
//var err error
|
|
if value, err := attr.ID.Value(); err == nil && value != nil {
|
|
return value.(int64)
|
|
}
|
|
return -1
|
|
}
|
|
|
|
func (attr Attr) GetCreatedAt() (t time.Time) {
|
|
//var err error
|
|
if value, err := attr.CreatedAt.Value(); err == nil && value != nil {
|
|
t = value.(time.Time)
|
|
return
|
|
}
|
|
return t
|
|
}
|
|
|
|
func (attr Attr) GetUpdatedAt() (t time.Time) {
|
|
//var err error
|
|
if value, err := attr.UpdatedAt.Value(); err == nil && value != nil {
|
|
t = value.(time.Time)
|
|
return
|
|
}
|
|
return t
|
|
}
|
|
|
|
func (attr Attr) GetAccessedAt() (t time.Time) {
|
|
//var err error
|
|
if value, err := attr.AccessedAt.Value(); err == nil && value != nil {
|
|
t = value.(time.Time)
|
|
return
|
|
}
|
|
return t
|
|
}
|
|
|
|
func (attr Attr) GetDeletedAt() (t time.Time) {
|
|
//var err error
|
|
if value, err := attr.DeletedAt.Value(); err == nil && value != nil {
|
|
t = value.(time.Time)
|
|
return
|
|
}
|
|
return t
|
|
}
|
|
|
|
// GetIDString returns the string value of attr's ID.
|
|
func (attr Attr) GetIDString() string {
|
|
var err error
|
|
if value, err := attr.ID.Value(); err == nil && value != nil {
|
|
return strconv.Itoa(int(value.(int64)))
|
|
}
|
|
log.Fatal("Attr is not loaded, has no id")
|
|
check(err)
|
|
return ""
|
|
}
|
|
|
|
// GetMark returns the int value of attr's mark
|
|
func (attr Attr) GetMark() int {
|
|
var err error
|
|
if value, err := attr.Mark.Value(); err == nil && value != nil {
|
|
return int(value.(int64))
|
|
}
|
|
log.Fatal("Mark is not loaded, has no 'mark'")
|
|
check(err)
|
|
return 0
|
|
}
|
|
|
|
// GetIdentifier returns attr's ID, or its Alias if it is not nil.
|
|
func (attr Attr) GetIdentifier() string {
|
|
alias := attr.GetAlias()
|
|
if len(alias) > 0 {
|
|
return alias
|
|
} else {
|
|
return attr.GetIDString()
|
|
}
|
|
}
|
|
|
|
// GetName is a helper to get attr's Name as string
|
|
func (attr Attr) GetName() string {
|
|
var err error
|
|
|
|
if value, err := attr.Name.Value(); err == nil && value != nil {
|
|
return value.(string)
|
|
}
|
|
log.Fatal("Attr is not loaded, has no name")
|
|
check(err)
|
|
return ""
|
|
}
|
|
|
|
// GetName is a helper to get attr's Name as string
|
|
func (attr Attr) GetAlias() string {
|
|
var err error
|
|
|
|
if value, err := attr.Alias.Value(); err == nil && value != nil {
|
|
return value.(string)
|
|
}
|
|
check(err)
|
|
return ""
|
|
}
|
|
|
|
// GetTextValue returns a string representation of attr's value, whatever type it is
|
|
func (attr Attr) GetTextValue() string {
|
|
var err error
|
|
if value, err := attr.ValueText.Value(); err == nil && value != nil {
|
|
return value.(string)
|
|
}
|
|
check(err)
|
|
return ""
|
|
}
|
|
|
|
// GetValue returns a string representation of attr's value, in order of
|
|
// preference: first ValueBlob, then ValueText, then ValueInt, then ValueReal
|
|
func (attr Attr) GetValue() string {
|
|
var err error
|
|
|
|
// if ValueBlov exists
|
|
if len(attr.ValueBlob) > 0 {
|
|
return string(attr.ValueBlob)
|
|
}
|
|
|
|
if value, err := attr.ValueText.Value(); err == nil && value != nil {
|
|
return value.(string)
|
|
}
|
|
check(err)
|
|
|
|
if value, err := attr.ValueInt.Value(); err == nil && value != nil {
|
|
return strconv.Itoa(value.(int))
|
|
}
|
|
check(err)
|
|
|
|
if value, err := attr.ValueReal.Value(); err == nil && value != nil {
|
|
return strconv.FormatFloat(value.(float64), 'f', 2, 32)
|
|
}
|
|
check(err)
|
|
|
|
log.Fatal("Attr is not loaded, has no value")
|
|
|
|
return ""
|
|
}
|
|
|
|
// Print pretty-prints attr's field values.
|
|
func (attr Attr) Print(w *tabwriter.Writer, verbose bool, indent int, highlighteds []string, after int) {
|
|
debug := false
|
|
|
|
if debug {
|
|
if value, err := attr.ParentID.Value(); err == nil && value != nil {
|
|
fmt.Fprintf(w, "%s:%d\t", "ParentID", value)
|
|
} else {
|
|
fmt.Fprintf(w, "%s:%s\t", "ParentID", novalue)
|
|
}
|
|
|
|
if value, err := attr.Name.Value(); err == nil && value != nil {
|
|
fmt.Fprintf(w, "%s:%s\t", "Name", value)
|
|
} else {
|
|
fmt.Fprintf(w, "%s:%s\t", "Name", novalue)
|
|
}
|
|
|
|
if value, err := attr.ValueText.Value(); err == nil && value != nil {
|
|
fmt.Fprintf(w, "%s:%s\t", "ValueText", value)
|
|
} else {
|
|
fmt.Fprintf(w, "%s:%s\t", "ValueText", novalue)
|
|
}
|
|
|
|
if attr.ValueBlob != nil {
|
|
fmt.Fprintf(w, "%s:%d\t", "ValueBlob-len", len(attr.ValueBlob))
|
|
} else {
|
|
fmt.Fprintf(w, "%s:%s\t", "ValueBlob-len", novalue)
|
|
}
|
|
} else {
|
|
// Last modifier:
|
|
//fmt.Fprintf(w, "%s\t", prettyAttr("at", attr.prettyAt()))
|
|
|
|
// Name:
|
|
//fmt.Fprintf(w, "%s\t", prettyAttr("name", attr.GetName()))
|
|
|
|
// Value:
|
|
//fmt.Printf(strings.Repeat(" ", indent))
|
|
|
|
if attr.GetMark() == 0 {
|
|
fmt.Printf("%s%s %s\n", Color("ID:", "default"), Color(attr.GetIdentifier(), "yellow+b"), attr.Title())
|
|
} else {
|
|
fmt.Printf("%s%s %s\n", Color("ID:", "black:white"), Color(attr.GetIdentifier(), "black+b:white"), Color(attr.Title(), "default"))
|
|
}
|
|
if len(highlighteds) > 0 {
|
|
fmt.Println(attr.PrettyMatches(highlighteds, after))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (attr Attr) PrettyMatches(highlighteds []string, after int) string {
|
|
var valueText string
|
|
if len(highlighteds) == 0 {
|
|
valueText = attr.Title()
|
|
} else {
|
|
valueText = strings.TrimSpace(attr.GetValue())
|
|
|
|
matchinglines := make([]string, 0, 0)
|
|
|
|
lastMatchingLine := -1
|
|
var matchCounter int
|
|
for linenumber, line := range strings.Split(valueText, "\n") {
|
|
line = strings.TrimSpace(line)
|
|
isCoveredByLastMatch := lastMatchingLine != -1 && linenumber <= lastMatchingLine+after
|
|
|
|
line, matched := highlightLine(line, highlighteds)
|
|
if matched {
|
|
lastMatchingLine = linenumber
|
|
if true { // !isCoveredByLastMatch {
|
|
matchCounter += 1
|
|
}
|
|
}
|
|
if matched || isCoveredByLastMatch {
|
|
prefix := fmt.Sprintf("%s L%s:", strings.Repeat(" ", len(attr.GetIdentifier())), strconv.Itoa(linenumber+1))
|
|
matchinglines = append(matchinglines, Color(prefix, "black")+line)
|
|
if maximumShownMatches != -1 && matchCounter >= maximumShownMatches {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
valueText = strings.Join(matchinglines, "\n")
|
|
}
|
|
return valueText + "\n"
|
|
}
|
|
|
|
func (attr Attr) Title() string {
|
|
valueText := strings.TrimSpace(attr.GetTextValue())
|
|
firstLineEndIndex := strings.Index(valueText, "\n")
|
|
|
|
if firstLineEndIndex >= 0 {
|
|
valueText = valueText[0:firstLineEndIndex]
|
|
} else {
|
|
if len(valueText) > 80 {
|
|
valueText = valueText[0:80] + ellipsis
|
|
}
|
|
}
|
|
return valueText
|
|
}
|
|
|
|
func (attr Attr) prettyAt() string {
|
|
if attr.GetUpdatedAt().IsZero() {
|
|
return attr.GetCreatedAt().Local().Format(datelayout) // + " "
|
|
} else {
|
|
return attr.GetUpdatedAt().Local().Format(datelayout) // + "*"
|
|
}
|
|
}
|
|
|
|
func (attr Attr) prettyCreatedAt() string {
|
|
return attr.GetCreatedAt().Local().Format(datelayout)
|
|
}
|
|
|
|
func (attr Attr) prettyUpdatedAt() string {
|
|
if !attr.GetUpdatedAt().IsZero() {
|
|
return attr.GetUpdatedAt().Local().Format(datelayout)
|
|
} else {
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func (attr Attr) Filepath() string {
|
|
f, err := ioutil.TempFile("", "eton-edit")
|
|
check(err)
|
|
writeToFile(f.Name(), attr.GetValue())
|
|
return f.Name()
|
|
}
|
|
|
|
// SetAlias sets attr's Alias to the given alias.
|
|
// If give alias is empty string, it will unset the alias (set it to NULL in the database).
|
|
func (attr Attr) SetAlias(db *sql.DB, alias string) {
|
|
|
|
unset := len(alias) == 0
|
|
if !unset {
|
|
var validAlias = regexp.MustCompile(`[^\s\d]+`)
|
|
if !validAlias.MatchString(alias) {
|
|
fmt.Println("Alias must contain a non-numeric character")
|
|
return
|
|
}
|
|
}
|
|
|
|
stmt, err := db.Prepare("UPDATE attributes SET alias = ? WHERE id = ?")
|
|
check(err)
|
|
|
|
//var result sql.Result
|
|
if !unset {
|
|
_, err = stmt.Exec(alias, attr.GetID())
|
|
} else {
|
|
_, err = stmt.Exec(nil, attr.GetID())
|
|
}
|
|
//check(err)
|
|
if err == nil {
|
|
if unset {
|
|
fmt.Printf("alias NULL set for ID:%d\n", attr.GetID())
|
|
} else {
|
|
fmt.Printf("alias \"%s\" set for ID:%d\n", alias, attr.GetID())
|
|
}
|
|
} else {
|
|
log.Fatalf("error while setting alias \"%s\" for ID:%d -- alias must be unique\n", alias, attr.GetID()) // , err)
|
|
}
|
|
//rowsAffected, err := result.RowsAffected()
|
|
}
|
|
|
|
func (attr Attr) SetMark(db *sql.DB, mark int) (rowsAffected int64) {
|
|
stmt, err := db.Prepare("UPDATE attributes SET mark = ? WHERE id = ? AND deleted_at IS NULL")
|
|
check(err)
|
|
|
|
result, err := stmt.Exec(mark, attr.GetID())
|
|
check(err)
|
|
rowsAffected, err = result.RowsAffected()
|
|
check(err)
|
|
|
|
return rowsAffected
|
|
}
|
|
|
|
func (attr Attr) Rm(db *sql.DB) (rowsAffected int64) {
|
|
stmt, err := db.Prepare("UPDATE attributes SET deleted_at = CURRENT_TIMESTAMP WHERE id = ? AND deleted_at IS NULL")
|
|
check(err)
|
|
|
|
result, err := stmt.Exec(attr.GetID())
|
|
check(err)
|
|
rowsAffected, err = result.RowsAffected()
|
|
check(err)
|
|
|
|
return rowsAffected
|
|
}
|
|
|
|
func (attr Attr) Unrm(db *sql.DB) (rowsAffected int64) {
|
|
stmt, err := db.Prepare("UPDATE attributes SET deleted_at = NULL WHERE id = ? AND deleted_at IS NOT NULL")
|
|
check(err)
|
|
|
|
result, err := stmt.Exec(attr.GetID())
|
|
check(err)
|
|
rowsAffected, err = result.RowsAffected()
|
|
check(err)
|
|
|
|
return rowsAffected
|
|
}
|
|
|
|
func (attr Attr) IncrementFrequency(db *sql.DB) (rowsAffected int64) {
|
|
stmt, err := db.Prepare("UPDATE attributes SET frequency = frequency + 1 WHERE id = ? AND deleted_at IS NULL")
|
|
check(err)
|
|
|
|
result, err := stmt.Exec(attr.GetID())
|
|
check(err)
|
|
|
|
rowsAffected, err = result.RowsAffected()
|
|
check(err)
|
|
return
|
|
}
|
|
|
|
func (attr Attr) Edit(db *sql.DB) (rowsAffected int64) {
|
|
// f, err := ioutil.TempFile("", "eton-edit")
|
|
// check(err)
|
|
// writeToFile(f.Name(), attr.GetValue())
|
|
filepath := attr.Filepath()
|
|
|
|
openEditor(filepath)
|
|
value_text := readFile(filepath)
|
|
if value_text != attr.GetValue() {
|
|
update_stmt, err := db.Prepare("UPDATE attributes SET value_text = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?")
|
|
check(err)
|
|
|
|
result, err := update_stmt.Exec(value_text, attr.GetID())
|
|
check(err)
|
|
rowsAffected, err = result.RowsAffected()
|
|
check(err)
|
|
}
|
|
return
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
func writeToFile(filepath string, content string) {
|
|
err := ioutil.WriteFile(filepath, []byte(content), 0644)
|
|
check(err)
|
|
}
|
|
|
|
func highlightLine(line string, highlighteds []string) (string, bool) {
|
|
if len(highlighteds) == 0 {
|
|
return line, false
|
|
} else {
|
|
reFlags := "(?i)"
|
|
re := regexp.MustCompile(reFlags + "(" + strings.Join(highlighteds, "|") + ")")
|
|
if indexes := re.FindStringIndex(line); indexes != nil {
|
|
var indexBegin int
|
|
var indexEnd int
|
|
var beforeStr string
|
|
var afterStr string
|
|
|
|
if len(indexes) > 0 {
|
|
firstIndex := indexes[0]
|
|
indexBegin = firstIndex - 40
|
|
if indexBegin < 0 {
|
|
indexBegin = 0
|
|
}
|
|
if indexBegin != 0 {
|
|
beforeStr = ellipsis
|
|
}
|
|
indexEnd = firstIndex + 40
|
|
} else {
|
|
indexEnd = 80
|
|
}
|
|
|
|
if indexEnd > indexBegin+80 {
|
|
indexEnd = indexBegin + 80
|
|
}
|
|
if indexEnd > len(line) {
|
|
indexEnd = len(line)
|
|
}
|
|
if indexEnd != len(line) {
|
|
afterStr = ellipsis
|
|
}
|
|
|
|
line = re.ReplaceAllString(line[indexBegin:indexEnd], Color("$0", "black+b:green"))
|
|
return beforeStr + line + afterStr, true
|
|
}
|
|
return line, false
|
|
}
|
|
}
|
|
|
|
func prettyAttr(name, value string) string {
|
|
if len(name) > 0 {
|
|
name = name + ":"
|
|
}
|
|
if termutil.Isatty(os.Stdout.Fd()) {
|
|
return ansi.Color(name, "black") + ansi.Color(value, "default")
|
|
} else {
|
|
return name + value
|
|
}
|
|
}
|
|
|
|
func prettyAttr2(name, value string) string {
|
|
if termutil.Isatty(os.Stdout.Fd()) {
|
|
return ansi.Color(name+":", "black") + ansi.Color(value, "blue")
|
|
} else {
|
|
return name + ":" + value
|
|
}
|
|
}
|
|
|
|
// Color is the same as ansi.Color but only if STDOUT is a TTY
|
|
func Color(str, color string) string {
|
|
if termutil.Isatty(os.Stdout.Fd()) {
|
|
return ansi.Color(str, color)
|
|
} else {
|
|
return str
|
|
}
|
|
}
|
|
|
|
func findAttributeByID(db *sql.DB, ID int64) (attr Attr) {
|
|
var err error
|
|
var stmt *sql.Stmt
|
|
|
|
defer func() {
|
|
if err == nil {
|
|
attr.IncrementFrequency(db)
|
|
}
|
|
}()
|
|
|
|
stmt, err = db.Prepare("SELECT " + sqlSelect + " FROM attributes WHERE id = ? AND deleted_at IS NULL LIMIT 1")
|
|
check(err)
|
|
|
|
err = stmt.QueryRow(ID).Scan(&attr.ID, &attr.ValueText, &attr.Name, &attr.ParentID, &attr.Alias, &attr.Mark, &attr.ValueBlob, &attr.CreatedAt, &attr.UpdatedAt)
|
|
if err != nil {
|
|
log.Fatalln("No record found with id", ID, err)
|
|
}
|
|
return
|
|
}
|
|
|
|
func findAttributeByAlias(db *sql.DB, alias string) (attr Attr) {
|
|
var err error
|
|
var stmt *sql.Stmt
|
|
|
|
defer func() {
|
|
if err == nil {
|
|
attr.IncrementFrequency(db)
|
|
}
|
|
}()
|
|
|
|
// Exact match
|
|
stmt, err = db.Prepare("SELECT " + sqlSelect + " FROM attributes WHERE alias = ? ORDER BY " + orderby + " LIMIT 1")
|
|
check(err)
|
|
err = stmt.QueryRow(alias).Scan(&attr.ID, &attr.ValueText, &attr.Name, &attr.ParentID, &attr.Alias, &attr.Mark, &attr.ValueBlob, &attr.CreatedAt, &attr.UpdatedAt)
|
|
if err == nil {
|
|
return
|
|
}
|
|
|
|
stmt, err = db.Prepare("SELECT " + sqlSelect + " FROM attributes WHERE alias LIKE ? ORDER BY " + orderby + " LIMIT 1")
|
|
check(err)
|
|
|
|
// Prefix match
|
|
err = stmt.QueryRow(alias+"%").Scan(&attr.ID, &attr.ValueText, &attr.Name, &attr.ParentID, &attr.Alias, &attr.Mark, &attr.ValueBlob, &attr.CreatedAt, &attr.UpdatedAt)
|
|
if err == nil {
|
|
return
|
|
}
|
|
|
|
// Postfix match
|
|
err = stmt.QueryRow("%"+alias).Scan(&attr.ID, &attr.ValueText, &attr.Name, &attr.ParentID, &attr.Alias, &attr.Mark, &attr.ValueBlob, &attr.CreatedAt, &attr.UpdatedAt)
|
|
if err == nil {
|
|
return
|
|
}
|
|
|
|
prunes := strings.Split(alias, "")
|
|
|
|
// Fuzzy match
|
|
err = stmt.QueryRow("%"+strings.Join(prunes, "%")+"%").Scan(&attr.ID, &attr.ValueText, &attr.Name, &attr.ParentID, &attr.Alias, &attr.Mark, &attr.ValueBlob, &attr.CreatedAt, &attr.UpdatedAt)
|
|
if err == nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func findAttributeByAliasOrID(db *sql.DB, alias_or_id string) (attr Attr) {
|
|
attr = findAttributeByAlias(db, alias_or_id)
|
|
if attr.GetID() <= 0 {
|
|
|
|
intID, err := strconv.Atoi(alias_or_id)
|
|
|
|
if err != nil {
|
|
return attr
|
|
}
|
|
|
|
attr = findAttributeByID(db, int64(intID))
|
|
}
|
|
|
|
return attr
|
|
}
|
|
|
|
func listWithFilters(db *sql.DB, opts Options) (attrs []Attr) {
|
|
var stmt *sql.Stmt
|
|
var rows *sql.Rows
|
|
var nolimit = opts.Limit == -1
|
|
|
|
var sqlConditions string
|
|
var sqlLimit string
|
|
|
|
queryValues := make([]interface{}, 0, 5)
|
|
|
|
if opts.RemovedOnly {
|
|
sqlConditions = "deleted_at IS NOT NULL"
|
|
} else {
|
|
sqlConditions = "deleted_at IS NULL"
|
|
}
|
|
|
|
if opts.RootID == -1 {
|
|
sqlConditions += " AND parent_id IS NULL"
|
|
} else {
|
|
nolimit = true
|
|
sqlConditions += fmt.Sprintf(" AND parent_id = %d ", opts.RootID)
|
|
}
|
|
|
|
if !opts.Recursive {
|
|
sqlConditions += " AND parent_id IS NULL"
|
|
}
|
|
|
|
if opts.ShortMode {
|
|
// sqlConditions += " AND ((alias IS NOT NULL AND alias != '') OR mark > 0)"
|
|
sqlConditions += " AND mark > 0"
|
|
}
|
|
|
|
if opts.RootID == -1 && len(opts.Filters) > 0 {
|
|
nolimit = true
|
|
nameOrVal := make([]string, 0, 0)
|
|
|
|
for _, filter := range opts.Filters {
|
|
likeValue := "%" + filter + "%"
|
|
// queryValues = append(queryValues, likeValue, likeValue, likeValue)
|
|
queryValues = append(queryValues, likeValue, likeValue)
|
|
|
|
// nameOrVal = append(nameOrVal, "(value_text LIKE ? OR name LIKE ? OR alias LIKE ?)")
|
|
nameOrVal = append(nameOrVal, "(value_text LIKE ? OR alias LIKE ?)")
|
|
}
|
|
|
|
sqlConditions += " AND ( " + strings.Join(nameOrVal, " AND ") + " )"
|
|
}
|
|
|
|
if nolimit {
|
|
sqlLimit = ""
|
|
} else {
|
|
queryValues = append(queryValues, opts.Offset)
|
|
queryValues = append(queryValues, opts.Limit)
|
|
sqlLimit = "LIMIT ?, ?"
|
|
}
|
|
|
|
// ===========================================================================
|
|
|
|
tx, err := db.Begin()
|
|
check(err)
|
|
stmt, err = tx.Prepare("SELECT " + sqlSelect + " FROM attributes WHERE " + sqlConditions + " ORDER BY " + orderby + " " + sqlLimit)
|
|
check(err)
|
|
defer stmt.Close()
|
|
rows, err = stmt.Query(queryValues...)
|
|
check(err)
|
|
defer rows.Close()
|
|
|
|
attrs = make([]Attr, 0, 0)
|
|
|
|
for rows.Next() {
|
|
attr := Attr{}
|
|
err = rows.Scan(&attr.ID, &attr.ValueText, &attr.Name, &attr.ParentID, &attr.Alias, &attr.Mark, &attr.ValueBlob, &attr.CreatedAt, &attr.UpdatedAt)
|
|
check(err)
|
|
attrs = append(attrs, attr)
|
|
|
|
var optsNew Options
|
|
optsNew = opts
|
|
optsNew.RootID = attr.GetID()
|
|
optsNew.Indent += 2
|
|
//cmdLs(db, w, optsNew)
|
|
}
|
|
|
|
tx.Commit()
|
|
return attrs
|
|
}
|
|
|
|
func getLastAttrID(db *sql.DB) int64 {
|
|
// Experimental
|
|
var ID int64
|
|
|
|
stmt, err := db.Prepare("SELECT id FROM attributes WHERE deleted_at IS NULL ORDER BY " + orderby + " LIMIT 1")
|
|
check(err)
|
|
|
|
err = stmt.QueryRow().Scan(&ID)
|
|
check(err)
|
|
return ID
|
|
}
|
|
|
|
func saveString(db *sql.DB, value_text string) (lastInsertId int64) {
|
|
new_stmt, err := db.Prepare("INSERT INTO attributes (name, value_text) VALUES ('note', ?)")
|
|
check(err)
|
|
|
|
result, err := new_stmt.Exec(value_text)
|
|
check(err)
|
|
|
|
lastInsertId, err = result.LastInsertId()
|
|
check(err)
|
|
|
|
return
|
|
}
|
|
|
|
func InitializeDatabase(db *sql.DB) bool {
|
|
sqlStmt := `
|
|
DROP TABLE IF EXISTS attributes;
|
|
CREATE TABLE attributes (
|
|
id INTEGER NOT NULL PRIMARY KEY,
|
|
name TEXT,
|
|
alias TEXT,
|
|
parent_id INTEGER,
|
|
frequency INTEGER DEFAULT 0,
|
|
mark INTEGER DEFAULT 0,
|
|
-- pwd TEXT,
|
|
|
|
value_text TEXT,
|
|
value_blob BLOB,
|
|
value_int INTEGER,
|
|
value_real REAL,
|
|
value_time DATETIME,
|
|
|
|
accessed_at DATETIME,
|
|
updated_at DATETIME,
|
|
deleted_at DATETIME,
|
|
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
|
|
CREATE UNIQUE INDEX IF NOT EXISTS index_on_alias ON attributes (alias);
|
|
CREATE INDEX IF NOT EXISTS index_on_name ON attributes (name);
|
|
CREATE INDEX IF NOT EXISTS index_on_value_text ON attributes (value_text);
|
|
CREATE INDEX IF NOT EXISTS index_on_value_blob ON attributes (value_blob);
|
|
CREATE INDEX IF NOT EXISTS index_on_value_int ON attributes (value_int);
|
|
CREATE INDEX IF NOT EXISTS index_on_value_real ON attributes (value_real);
|
|
CREATE INDEX IF NOT EXISTS index_on_accessed_at ON attributes (accessed_at);
|
|
CREATE INDEX IF NOT EXISTS index_on_deleted_at ON attributes (deleted_at);
|
|
CREATE INDEX IF NOT EXISTS index_on_frequency ON attributes (frequency);
|
|
CREATE INDEX IF NOT EXISTS index_on_mark ON attributes (mark);
|
|
`
|
|
_, err := db.Exec(sqlStmt)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
return false
|
|
}
|
|
fmt.Println("repository initiated")
|
|
return true
|
|
}
|
|
|
|
// NullTime allows timestamps to be NULL
|
|
type NullTime struct {
|
|
Time time.Time
|
|
Valid bool // Valid is true if Time is not NULL
|
|
}
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (nt *NullTime) Scan(value interface{}) error {
|
|
nt.Time, nt.Valid = value.(time.Time)
|
|
return nil
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (nt NullTime) Value() (driver.Value, error) {
|
|
if !nt.Valid {
|
|
return nil, nil
|
|
}
|
|
return nt.Time, nil
|
|
}
|