// Set associates the plain text password given with the user that is uniquely // identified by id. The password is hashed with bcrypt. If there is a problem // with hashing or with storing the password, an error is returned. // // This may be called on a new user. func (s *Store) Set(id, password string) (cerr error) { defer csql.Safe(&cerr) hash, err := bcrypt.GenerateFromPassword( []byte(password), bcrypt.DefaultCost) if err != nil { return err } // This lock can be avoided if we use some sort of upsert. // It's possible with Postgres, but this is just way easier. locker.Lock(id) defer locker.Unlock(id) n := csql.Count(s, ` SELECT COUNT(*) FROM `+SqlTableName+` WHERE id = $1 `, id) if n == 0 { csql.Exec(s, ` INSERT INTO `+SqlTableName+` (id, hash) VALUES ($1, $2) `, id, hash) } else { csql.Exec(s, ` UPDATE `+SqlTableName+` SET id = $1, hash = $2 WHERE id = $1 `, id, hash) } return nil }
func (d *document) isDuplicate() bool { n := csql.Count(db, ` SELECT COUNT(*) FROM document WHERE project_owner = $1 AND project_name = $2 AND name = $3 AND recorded = $4 `, d.Project.Owner.Id, d.Project.Name, d.Name, d.Recorded) return n > 0 }
// countEpisodes returns the number of episodes for the TV show given. func countEpisodes(e imdb.Entity) int { assertDB() q := ` SELECT COUNT(*) FROM episode WHERE tvshow_atom_id = $1 AND season > 0 AND episode_num > 0 ` return csql.Count(tplDB, q, e.Ident()) }
// tableSize returns a pretty string indicating the size in table. Row count // is always include, but the size on disk is only included if it's supported // by the database. // Note that 'name' is assumed to be SQL-safe. func tableSize(db *imdb.DB, name string) string { count := csql.Count(db, sf("SELECT COUNT(*) AS count FROM %s", name)) if db.Driver == "sqlite3" { return sf("%d rows", count) } var size string q := sf("SELECT pg_size_pretty(pg_relation_size('%s'))", name) csql.Scan(db.QueryRow(q), &size) return sf("%d rows (%s)", count, size) }
// isDuplicate returns true if the project already exists. func (proj *project) isDuplicate() bool { n := csql.Count(db, ` SELECT COUNT(*) FROM project WHERE owner = $1 AND name = $2 `, proj.Owner.Id, proj.Name) return n > 0 }
func TestLoadMovies(t *testing.T) { var exp = map[string]int{ "movies": 4, "tvs": 1, "episodes": 2, } if err := loadMovies(testDriver, testDsn, testLists); err != nil { t.Fatal(err) } movies := csql.Count(testDB, "SELECT COUNT(*) FROM movie") tvs := csql.Count(testDB, "SELECT COUNT(*) FROM tvshow") episodes := csql.Count(testDB, "SELECT COUNT(*) FROM episode") if movies != exp["movies"] { t.Fatalf("Expected %d movies but got %d", exp["movies"], movies) } if tvs != exp["tvs"] { t.Fatalf("Expected %d tvs but got %d", exp["tvs"], tvs) } if episodes != exp["episodes"] { t.Fatalf("Expected %d episodes but got %d", exp["episodes"], episodes) } }
// countSeasons returns the number of seasons for the TV show given. func countSeasons(e imdb.Entity) int { assertDB() q := ` SELECT COUNT(*) FROM ( SELECT season FROM episode WHERE tvshow_atom_id = $1 AND season > 0 AND episode_num > 0 GROUP BY season ) AS sub ` return csql.Count(tplDB, q, e.Ident()) }
// Returns the number of rows in the table given. This will panic with a // csql.Panic error if the query fails. func rowCount(db *imdb.DB, table string) int { return csql.Count(db, sf("SELECT COUNT(*) FROM %s", table)) }