Golang gocql.Session类代码示例

// Function handle new use creating
func createUser(body *[]byte, session *gocql.Session) (int, error) {
	var request newUserRequest
	var count int

	err := json.Unmarshal(*body, &request)
	if err != nil {
		return http.StatusBadRequest, err
	}

	// Here should be call of function to extended validation, but nothing was in requirements
	if request.Password == "" || request.Username == "" {
		return http.StatusBadRequest, errors.New("User or password is empty")
	}

	// Check if such user already existing
	err = session.Query("SELECT COUNT(*) from users where username = '" + request.Username + "'").Scan(&count)
	if err != nil {
		return http.StatusInternalServerError, err
	}

	if count > 0 {
		return http.StatusConflict, errors.New("Such user alredy existing")
	}

	// Prepare password hash to write it to DB
	hash := sha256.New()
	hash.Write([]byte(request.Password))

	err = session.Query("INSERT INTO users (username,password) VALUES (?,?)", request.Username, hex.EncodeToString(hash.Sum(nil))).Exec()
	if err != nil {
		return http.StatusInternalServerError, err
	}

	return http.StatusCreated, nil
}

func add_new_file(session *gocql.Session, w http.ResponseWriter, r *http.Request) {
	/*
		Adds a new file to Cassandra via a POST.
	*/

	// Instantiate the struct.
	file := Asset{}

	// Decodes the json POST.
	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&file)
	if err != nil {
		log.Printf("Failed to decode: %s\n", err)
	}

	// We create the creation time instead of the client.
	created := time.Now()

	log.Printf("%s added new file: %s, Originally created at %s in %s. Exists in MA01: %t. Exists in TX01: %t.", strings.Split(r.RemoteAddr, ":")[0], file.Fid, file.Created, strings.ToUpper(file.Origin), file.Ma01, file.Tx01)

	// Execute the insert, at CL:ALL.
	if err := session.Query(`
		INSERT INTO file_ledger (fid, created, origin, ma01, tx01)
		VALUES (?, ?, ?, ?, ?) 
		IF NOT EXISTS`, &file.Fid, created, &file.Origin, &file.Ma01, &file.Tx01).Consistency(gocql.All).Exec(); err != nil {
		log.Printf("Failed to insert: %s\n", err)
		fail_resp := []byte(`{"insert":"fail"}`)
		w.Write(fail_resp)
	} else {
		ok_resp := []byte(`{"insert":"success"}`)
		w.Write(ok_resp)
	}
}

func update_file(session *gocql.Session, dc string, w http.ResponseWriter, r *http.Request) {
	/*
		Updates a new file in Cassandra via a POST.
	*/

	// Instantiate the struct.
	file := Asset{}

	// Decodes the json POST.
	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&file)
	if err != nil {
		log.Printf("Failed to decode: %s\n", err)
	}

	log.Printf("%s toggled file %s as true in %s", strings.Split(r.RemoteAddr, ":")[0], file.Fid, strings.ToUpper(dc))

	// Compose the CQL query.
	query := fmt.Sprintf(`
		UPDATE file_ledger
		SET %s = true
		WHERE fid = '%s'`, dc, file.Fid)

	// Execute the insert, at ConsistancyLevel:ALL.
	if err := session.Query(query).Consistency(gocql.All).Exec(); err != nil {
		log.Printf("Failed to update: %s\n", err)
		fail_resp := []byte(`{"update":"fail"}`)
		w.Write(fail_resp)
	} else {
		ok_resp := []byte(`{"update":"success"}`)
		w.Write(ok_resp)
	}

}

// UserQ ...
func UserQ(session *gocql.Session, query string) map[string]interface{} {
	user := map[string]interface{}{"id": 0, "name": ""}

	session.Query(query).MapScan(user)

	return user
}

func (asset *Asset) Find(session *gocql.Session, assetId string) (*Asset, error) {
	var id gocql.UUID
	var name string
	var path string
	var contentType string
	var createdAt time.Time
	var binary []byte

	// Check if the assetId is an valid UUID
	idCheck, err := gocql.ParseUUID(assetId)
	if err != nil {
		return nil, err
	}

	if idCheck.Timestamp() == 0 {
		return nil, errors.New("Invalid UUID")
	}

	if err := session.Query(`SELECT id, name, path, contenttype, createdat, binary FROM assets WHERE id = ? LIMIT 1`,
		assetId).Consistency(gocql.One).Scan(&id, &name, &path, &contentType, &createdAt, &binary); err != nil {
		return nil, err
	}

	return &Asset{id, name, strings.Split(path, ","), contentType, createdAt, binary}, nil
}

func worker(session *gocql.Session, ch chan *sample) {
	for s := range ch {
		if err := session.Query(`INSERT INTO samples (metric, timestamp, value) VALUES (?, ?, ?)`,
			s.name, s.timestamp, s.value).Exec(); err != nil {
			log.Fatalf("Query error: %s", err)
		}
	}
}

func Truncate(session *gocql.Session, table cqlc.Table) {
	stmt := fmt.Sprintf("truncate %s", table.TableName())
	err := session.Query(stmt).Exec()

	if err != nil {
		log.Fatalf("Could not %s: %v", stmt, err)
		os.Exit(1)
	}
}

func tearDown(t *testing.T, session *gocql.Session) {

	defer session.Close()
	//	if err := session.Query(`Drop Table message`).Exec(); err != nil {
	//		t.Log("can not drop Table testdata")
	//		t.Fatal(err.Error())
	//	}

}

// CreateTweet creates a new tweet
func CreateTweet(s *gocql.Session, tweet *Tweet) error {
	q1 := `INSERT INTO tweets_by_id (id, tweet) VALUES (?,?);`
	q2 := `UPDATE users_by_name SET tweets = tweets + [?] WHERE name = ?;`
	err := s.Query(q1, tweet.ID, tweet).Exec()
	if err != nil {
		return err
	}
	return s.Query(q2, tweet, tweet.Username).Exec()
}

func getDefinition(session *gocql.Session, words []string) string {
	var defn string
	thingtodefine := strings.ToLower(strings.Join(words, " "))
	iter := session.Query("select defn from words where word = ?", thingtodefine).Consistency(gocql.One).Iter()
	for iter.Scan(&defn) {
		return fmt.Sprintf("'%s': %s", thingtodefine, defn)
	}
	return fmt.Sprintf("Sorry I don't know about '%s'", thingtodefine)
}

func insertSerieIds(session *gocql.Session, serieIdsToInsert []gocql.UUID) error {
	insertSerieQuery := session.Query("INSERT INTO \"SerieId\" (\"SerieId\") VALUES (?);")

	for _, id := range serieIdsToInsert {
		if err := insertSerieQuery.Bind(id).Exec(); err != nil {
			return err
		}
	}
	return nil
}

func (asset Asset) FindByPath(session *gocql.Session, path string) ([]Asset, error) {
	var id gocql.UUID
	var name string
	var assets = make([]Asset, 0)
	iter := session.Query(`SELECT id, name FROM assetbypaths WHERE path = ?`, path).Iter()
	for iter.Scan(&id, &name) {
		assets = append(assets, Asset{Id: id, Name: name, Path: strings.Split(path, ",")})
	}
	return assets, nil
}

func injectEvent(session *gocql.Session, resId string) error {
	t := time.Now().UTC()
	err := session.Query(`INSERT INTO resources_simple(event_time, resource_id, event) VALUES (?, ?, ?)`,
		t, resId, fmt.Sprintf(`{"message":"Hello World", "ts":"%s"}`, t.Format(time.RFC3339Nano))).Exec()

	if err != nil {
		log.Printf("Error with insert for id: %s: %s", resId, err)
		return fmt.Errorf("insert error:", err)
	}
	return nil
}

func Migrate_0_9_1_to_15_04_03(session *gocql.Session) error {
	// Perform all migration queries.
	for _, query := range migrationQueries_0_9_1_to_15_04_03 {
		canolog.Info(query)
		if err := session.Query(query).Exec(); err != nil {
			// Ignore errors (just print them).
			canolog.Warn(query, ": ", err)
		}
	}
	return nil
}

func cleanup(session *gocql.Session) error {
	if err := session.Query("TRUNCATE \"SerieId\";").Exec(); err != nil {
		return err
	}

	if err := session.Query("TRUNCATE \"Timeserie\"").Exec(); err != nil {
		return err
	}

	return nil
}