func TestStructToMap(t *testing.T) {
//Test that if the value is not a struct we return nil, false
m, ok := StructToMap("str")
if m != nil {
t.Error("map is not nil when val is a string")
}
if ok {
t.Error("ok result from StructToMap when the val is a string")
}
tweet := Tweet{
"t",
gocql.TimeUUID(),
"ignored",
"hello gocassa",
nil,
}
m, ok = StructToMap(tweet)
if !ok {
t.Error("ok is false for a tweet")
}
if m["Timeline"] != tweet.Timeline {
t.Errorf("Expected %s but got %s", tweet.Timeline, m["Timeline"])
}
if m["id"] != tweet.ID {
t.Errorf("Expected %s but got %s", tweet.ID, m["id"])
}
if m["Text"] != tweet.Text {
t.Errorf("Expected %s but got %s", tweet.Text, m["Text"])
}
if m["OriginalTweet"] != tweet.OriginalTweet {
t.Errorf("Expected %v but got %s", tweet.OriginalTweet, m["OriginalTweet"])
}
if _, ok := m["Ignore"]; ok {
t.Errorf("Igonred should be empty but got %s instead", m["Ignored"])
}
id := gocql.TimeUUID()
tweet.OriginalTweet = &id
m, _ = StructToMap(tweet)
if m["OriginalTweet"] != tweet.OriginalTweet {
t.Errorf("Expected nil but got %s", m["OriginalTweet"])
}
}
func main() {
session := integration.TestSession("127.0.0.1", "cqlc")
integration.Truncate(session, EVENTS)
result := "FAILED"
ctx := cqlc.NewContext()
var sensorId int64 = 100
ctx.Upsert(EVENTS).
SetInt64(EVENTS.SENSOR, sensorId).
SetTimeUUID(EVENTS.TIMESTAMP, gocql.TimeUUID()).
SetFloat32(EVENTS.TEMPERATURE, 19.8).
SetInt32(EVENTS.PRESSURE, 357).
Exec(session)
iter, err := ctx.Select().
From(EVENTS).
Where(
EVENTS.SENSOR.Eq(sensorId),
EVENTS.TIMESTAMP.Lt(gocql.TimeUUID())).
Fetch(session)
if err != nil {
log.Fatalf("Could not execute query: %v", err)
return
}
events, err := BindEvents(iter)
if err != nil {
log.Fatalf("Could not bind data: %v", err)
return
}
err = iter.Close()
if err != nil {
log.Fatalf("Could not bind data: %v", err)
return
}
if len(events) == 1 {
result = "PASSED"
}
os.Stdout.WriteString(result)
}
func TestFieldsAndValues(t *testing.T) {
var emptyUUID gocql.UUID
id := gocql.TimeUUID()
var nilID *gocql.UUID
var tests = []struct {
tweet Tweet
fields []string
values []interface{}
}{
{
Tweet{},
[]string{"Timeline", "id", "Text", "OriginalTweet"},
[]interface{}{"", emptyUUID, "", nilID},
},
{
Tweet{"timeline1", id, "ignored", "hello gocassa", &id},
[]string{"Timeline", "id", "Text", "OriginalTweet"},
[]interface{}{"timeline1", id, "hello gocassa", &id},
},
}
for _, test := range tests {
fields, values, _ := FieldsAndValues(test.tweet)
assertFieldsEqual(t, test.fields, fields)
assertValuesEqual(t, test.values, values)
}
}
func (asset *Asset) Save(session *gocql.Session) error {
if asset.Id.Timestamp() == 0 {
asset.Id = gocql.TimeUUID()
if err := session.Query(`INSERT INTO assets (id, name, path, contenttype, createdat, binary) VALUES (?, ?, ?, ?, ?, ?)`,
asset.Id, asset.Name, strings.Join(asset.Path, ","), asset.ContentType, asset.CreatedAt, asset.Binary).Exec(); err != nil {
glog.Fatal(err)
return err
}
if err := session.Query(`INSERT INTO assetbypaths (path, id, name) VALUES (?, ?, ?)`,
strings.Join(asset.Path, ","), asset.Id, asset.Name).Exec(); err != nil {
glog.Fatal(err)
return err
}
return nil
} else {
if err := session.Query(`UPDATE assets SET name = ?, path = ?, contenttype = ? WHERE id = ?`,
asset.Name, strings.Join(asset.Path, ","), asset.ContentType, asset.Id).Exec(); err != nil {
glog.Fatal(err)
return err
}
if err := session.Query(`UPDATE assetbypaths SET name = ?, path = ? WHERE id = ?`,
asset.Name, strings.Join(asset.Path, ","), asset.Id).Exec(); err != nil {
glog.Fatal(err)
return err
}
return nil
}
}
func NewTweet(timeLine, text string) (tw *Tweet) {
tw = new(Tweet)
tw.Timeline = timeLine
tw.Text = text
tw.Id = gocql.TimeUUID()
return
}
func main() {
session := integration.TestSession("127.0.0.1", "cqlc")
session.SetPageSize(1000)
integration.Truncate(session, EVENTS)
result := "FAILED"
ctx := cqlc.NewContext()
batch := gocql.NewBatch(gocql.LoggedBatch)
rounds := 10
distinct := 10
for i := 0; i < rounds; i++ {
for j := 0; j < distinct; j++ {
ctx.Upsert(EVENTS).
SetInt64(EVENTS.SENSOR, int64(j)).
SetTimeUUID(EVENTS.TIMESTAMP, gocql.TimeUUID()).
SetFloat32(EVENTS.TEMPERATURE, 19.8).
SetInt32(EVENTS.PRESSURE, 357).
Batch(batch)
}
}
err := session.ExecuteBatch(batch)
if err != nil {
log.Fatalf("Could not execute batch: %v", err)
os.Exit(1)
}
iter, err := ctx.SelectDistinct(EVENTS.SENSOR).From(EVENTS).Fetch(session)
if err != nil {
log.Fatalf("Could not prepare query: %v", err)
os.Exit(1)
}
count := 0
MapEvents(iter, func(e Events) (bool, error) {
count++
return true, nil
})
if err := iter.Close(); err != nil {
log.Fatalf("Could not close iterator: %v", err)
os.Exit(1)
}
if count == distinct {
result = "PASSED"
} else {
result = fmt.Sprintf("Expected %d distinct rows; got %d", distinct, count)
}
os.Stdout.WriteString(result)
}
func (querier Querier) InsertCachedComment(id, htmlString string) error {
if err := querier.Session.Query(`INSERT INTO caches (id, post_id, content) VALUES (?, ?, ?)`,
gocql.TimeUUID(),
id,
htmlString).Exec(); err != nil {
return err
}
return nil
}
func TestHighLevelAPIOnly(t *testing.T) {
type Message struct {
Identifier gocql.UUID
Epoch int64
User string
Payload []byte
}
strat := map[string]string{
"id": "Identifier",
"unix": "Epoch",
"usr": "******",
"msg": "Payload",
}
s := setup(t, "queue")
msgs := 163
for i := 0; i < msgs; i++ {
msg := make([]byte, 64)
_, err := rand.Read(msg)
if err != nil {
t.Fatal(err)
}
m := Message{
Identifier: gocql.TimeUUID(),
Epoch: time.Now().Unix(),
User: "******",
Payload: msg,
}
if err := Bind(`INSERT INTO queue (id, unix, usr, msg) VALUES (?, ?, ?, ?)`, m).Map(strat).Exec(s); err != nil {
t.Fatal(err)
}
}
q := s.Query(`SELECT id, unix, usr, msg FROM queue`)
b := BindQuery(q).Map(strat)
count := 0
var m Message
for b.Scan(&m) {
count++
assert.Equal(t, "deamon", m.User)
}
err := b.Close()
assert.Nil(t, err, "Could not close binding")
assert.Equal(t, msgs, count)
}
func (this *Tweet) Save() error {
session, _ := db.cluster.CreateSession()
defer session.Close()
query := `INSERT INTO tweets (id, user, body) VALUES (?, ?, ?)`
if err := session.Query(query, gocql.TimeUUID(), this.User, this.Body).Exec(); err != nil {
return err
}
return nil
}
// Report failure stats to cassandra.
func (stat ValkyrieCassandraStats) Failure(err error, clientId, serviceId string) error {
hour := timestamp(HOUR)
id := gocql.TimeUUID()
insertStmt := "INSERT INTO request_errors (hour, client_id, service_id, id, reason) VALUES (?, ?, ?, ?, ?)"
e := stat.session.Query(insertStmt, hour, clientId, serviceId, id, err.Error()).Exec()
if e != nil {
log.Println(e)
return e
}
return nil
}
// Report trace stats to cassandra.
func (stat ValkyrieCassandraStats) Trace(event string, start, end time.Time, duration time.Duration) error {
hour := timestamp(HOUR)
id := gocql.TimeUUID()
insertStmt := "INSERT INTO traces (hour, event, start, end, duration, id) VALUES (?, ?, ?, ?, ?, ?)"
err := stat.session.Query(insertStmt, hour, event, start, end, duration.Nanoseconds(), id).Exec()
if err != nil {
log.Println(err)
return err
}
return nil
}
func (querier Querier) InsertSub(subName string) error {
if err := querier.Session.Query(`INSERT INTO subs (id, name, subscribers, created_at, updated_at) VALUES (?, ?, ?, ?, ?)`,
gocql.TimeUUID(),
subName,
0,
time.Now(),
time.Now()).Exec(); err != nil {
return err
}
return nil
}
// Report general failure stats to cassandra.
func (stat ValkyrieCassandraStats) GeneralFailure(err error) error {
hour := timestamp(HOUR)
id := gocql.TimeUUID()
insertStmt := "INSERT INTO errors (hour, id, reason) VALUES (?, ?, ?)"
e := stat.session.Query(insertStmt, hour, id, err.Error()).Exec()
if e != nil {
log.Println(e)
return e
}
return nil
}
func (suite *ExamplesSuite) SetupSuite() {
suite.id = gocql.TimeUUID()
suite.executeTemplate(upTemplate)
cluster := gocql.NewCluster(cassandraConfig.Hosts...)
cluster.Keyspace = cassandraConfig.Keyspace
if session, sessionErr := cluster.CreateSession(); nil == sessionErr {
suite.session = session
} else {
panic(sessionErr.Error())
}
}
//-----------------------------------------------------------------------------
// Test
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Insert
//-----------------------------------------------------------------------------
func TestInsert(t *testing.T) {
db := GetCass()
//INSERT
sql := `INSERT INTO t_users
(id, first_name, last_name, email, password, age, created_at, updated_at)
VALUES
(?, ?, ?, ?, ?, ?, ?, ?)`
err := db.Session.Query(sql, gocql.TimeUUID(), "taro", "yamada", "*****@*****.**", "aaaa", 24, time.Now(), time.Now()).Exec()
if err != nil {
t.Errorf("INSERT error: %s", err)
}
}
func (suite *ExamplesSuite) TestInstanceMapper_InsertQuery() {
exampleTable := &ExampleTable{
Id: gocql.TimeUUID(),
Value: "NewValue",
}
mapper, _ := cqlmapper.Underscore.NewInstanceMapper(exampleTable)
insertQuery := suite.session.Query(mapper.InsertQuery(), mapper.FieldValues()...)
if execErr := insertQuery.Exec(); nil != execErr {
panic(execErr.Error())
}
}
func (querier *Querier) InsertPost(subName, title, comment, link string) error {
if err := querier.Session.Query(`INSERT INTO posts (id, sub_id, title, comment, link, upvotes, downvotes, comment_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
gocql.TimeUUID(),
subName,
title,
comment,
link,
0,
0,
0,
time.Now(),
time.Now(),
).Exec(); err != nil {
return err
}
return nil
}
func (querier *Querier) InsertComment(postID, parentID, content string) error {
if err := querier.Session.Query(`INSERT INTO comments (id, post_id, parent_id, content, upvotes, downvotes, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
gocql.TimeUUID(),
postID,
parentID,
content,
0,
0,
time.Now(),
time.Now()).Exec(); err != nil {
return err
}
// err := querier.UpCommentCount(postID)
// if err !=nil{
// log.Println("UpCommentCount encountered error on id:", postID)
// return err
// }
return nil
}
// Create a new template record: a brand new template, a new template commit (version), or just a template release
func (t *Template) CreateTemplate() error {
//flatten files
files_str := ""
if &t.Files != nil && len(t.Files) > 0 {
var files []string
for _, file := range t.Files {
files = append(files, file.toString())
}
files_str = strings.Join(files, ",")
}
query_str := fmt.Sprintf(QUERY_STR_INSERT_TEMPLATE, gocql.TimeUUID(), t.Template_name, t.Template_hash, t.Commit_info.toString(), files_str, t.Release_info.toString())
//DEDBUG
fmt.Println(query_str)
err := Conn.Query(query_str).Exec()
return err
}
//TestNoCaseColumns is a test case to verify case insensitive columns are mapped properly
func TestNoCaseColumns(t *testing.T) {
type Tweet struct {
TimeLine string
Id gocql.UUID
Text string
}
s := setup(t, "tweet")
defer s.Close()
tw := Tweet{
TimeLine: "me",
Id: gocql.TimeUUID(),
Text: fmt.Sprintf("hello world %d", 1),
}
if err := Bind(`INSERT INTO tweet (timeline, Id, Text) VALUES (?, ?, ?)`, tw).Exec(s); err != nil {
t.Fatal(err)
}
}
func (p *Player) Create() error {
p.Exists = false
for {
p.UUID = gocql.TimeUUID()
var row = map[string]interface{}{}
var apply bool
var err error
if apply, err = CQLSession.Query(`insert into players (player_uuid,create_time) values (?,now()) if not exists`, p.UUID).MapScanCAS(row); err != nil {
logger.Error(errors.New(err))
return err
}
if apply {
break
}
}
return nil
}
func main() {
// NOTE: copied from gocql readme
cluster := gocql.NewCluster("192.168.99.100")
cluster.ProtoVersion = 4
cluster.Keyspace = "example"
cluster.Consistency = gocql.One // was ".Quorum"
session, _ := cluster.CreateSession()
defer session.Close()
// insert a tweet
if err := session.Query(`INSERT INTO tweet (timeline, id, text) VALUES (?, ?, ?)`,
"me", gocql.TimeUUID(), "hello world").Exec(); err != nil {
log.Fatal(err)
}
var id gocql.UUID
var text string
/* Search for a specific set of records whose 'timeline' column matches
* the value 'me'. The secondary index that we created earlier will be
* used for optimizing the search */
if err := session.Query(`SELECT id, text FROM tweet WHERE timeline = ? LIMIT 1`,
"me").Consistency(gocql.One).Scan(&id, &text); err != nil {
log.Fatal(err)
}
fmt.Println("Tweet:", id, text)
// list all tweets
iter := session.Query(`SELECT id, text FROM tweet WHERE timeline = ?`, "me").Iter()
for iter.Scan(&id, &text) {
fmt.Println("Tweet:", id, text)
}
if err := iter.Close(); err != nil {
log.Fatal(err)
}
}
//TestCasedColumns is a test case to verify case sensitive columns are mapped properly
func TestCasedColumns(t *testing.T) {
type Tweet struct {
TimeLine string `cql:"timeLine"`
Timeline string
Id gocql.UUID
Text string
}
s := setup(t, "tweetcase")
defer s.Close()
tw := Tweet{
TimeLine: "me",
Timeline: "me2",
Id: gocql.TimeUUID(),
Text: fmt.Sprintf("hello world %d", 1),
}
if err := Bind(`INSERT INTO tweetcase ("timeLine", timeline, Id, Text) VALUES (?,?, ?, ?)`, tw).Exec(s); err != nil {
t.Fatal(err)
}
q := s.Query(`SELECT "timeLine", timeline, Id, Text FROM tweetcase`)
b := BindQuery(q)
var twr Tweet
for b.Scan(&twr) {
assert.Equal(t, tw, twr)
}
err := b.Close()
assert.Nil(t, err, "Could not close binding")
}
func (s *Session) Create(remoteAddr string, userAgent string) {
s.Exists = false
for {
s.UUID = gocql.TimeUUID()
var row = model.Fields{}
var apply bool
var err error
if apply, err = CQLSession.Query(`insert into auth_sessions (session_uuid,last_access,create_time, remote_addr, user_agent) values (?,now(),now(),?,?) if not exists`, s.UUID, remoteAddr, userAgent).MapScanCAS(row); err != nil {
logger.Error(errors.New(err))
return
}
if apply {
break
}
}
s.Load()
}
func TestMapToStruct(t *testing.T) {
m := make(map[string]interface{})
assert := func() {
tweet := Tweet{}
if err := MapToStruct(m, &tweet); err != nil {
t.Fatal(err.Error())
}
timeline, ok := m["Timeline"]
if ok {
if timeline != tweet.Timeline {
t.Errorf("Expected timeline to be %s but got %s", timeline, tweet.Timeline)
}
} else {
if "" != tweet.Timeline {
t.Errorf("Expected timeline to be empty but got %s", tweet.Timeline)
}
}
id, ok := m["id"]
if ok {
if id != tweet.ID {
t.Errorf("Expected id to be %s but got %s", id, tweet.ID)
}
} else {
var emptyID gocql.UUID
if emptyID != tweet.ID {
t.Errorf("Expected id to be empty but got %s", tweet.ID)
}
}
text, ok := m["teXt"]
if ok {
if text != tweet.Text {
t.Errorf("Expected text to be %s but got %s", text, tweet.Text)
}
} else {
if "" != tweet.Text {
t.Errorf("Expected text to be empty but got %s", tweet.Text)
}
}
originalTweet, ok := m["OriginalTweet"]
if ok {
if originalTweet != tweet.OriginalTweet {
t.Errorf("Expected original tweet to be %s but got %s",
originalTweet, tweet.OriginalTweet)
}
} else {
if nil != tweet.OriginalTweet {
t.Errorf("Expected original tweet to be empty but got %s",
tweet.OriginalTweet)
}
}
//Ignored should be always empty
if tweet.Ingored != "" {
t.Errorf("Expected ignored to be empty but got %s",
tweet.Ingored)
}
}
assert()
m["Timeline"] = "timeline"
assert()
m["id"] = gocql.TimeUUID()
assert()
m["text"] = "Hello gocassa"
assert()
id := gocql.TimeUUID()
m["OriginalTweet"] = &id
assert()
m["Ignored"] = "ignored"
assert()
}
func (this *Tweet) GenerateId() {
this.Id = gocql.TimeUUID()
}
func main() {
session := integration.TestSession("127.0.0.1", "cqlc")
integration.Truncate(session, EVENTS)
result := "FAILED"
ctx := cqlc.NewContext()
batch := gocql.NewBatch(gocql.LoggedBatch)
events := 100
for i := 0; i < events; i++ {
ctx.Upsert(EVENTS).
SetInt64(EVENTS.SENSOR, int64(100)).
SetTimeUUID(EVENTS.TIMESTAMP, gocql.TimeUUID()).
SetFloat32(EVENTS.TEMPERATURE, 19.8).
SetInt32(EVENTS.PRESSURE, 357).
Batch(batch)
}
if err := session.ExecuteBatch(batch); err != nil {
log.Fatalf("Could not execute batch: %v", err)
os.Exit(1)
}
limit := 11
iter, err := ctx.Select(EVENTS.SENSOR).
From(EVENTS).
Limit(limit).
Fetch(session)
if err != nil {
log.Fatalf("Could not execute query: %v", err)
os.Exit(1)
}
count := 0
MapEvents(iter, func(e Events) (bool, error) {
count++
return true, nil
})
if count == limit {
limit = 14
iter, err = ctx.Select().
From(EVENTS).
Where(EVENTS.SENSOR.Eq(int64(100))).
Limit(limit).
Fetch(session)
count := 0
MapEvents(iter, func(e Events) (bool, error) {
count++
return true, nil
})
if count == limit {
result = "PASSED"
} else {
result = fmt.Sprintf("Expected limit of %d; got %d rows", limit, count)
}
} else {
result = fmt.Sprintf("Expected limit of %d; got %d rows", limit, count)
}
if err != nil {
log.Fatalf("Could not execute query: %v", err)
os.Exit(1)
}
os.Stdout.WriteString(result)
}
func main() {
session := integration.TestSession("127.0.0.1", "cqlc")
integration.Truncate(session, EVENTS)
result := "FAILED"
ctx := cqlc.NewContext()
batch := gocql.NewBatch(gocql.LoggedBatch)
events := 50 * 1000
batchSize := 1000
for i := 0; i < events; i++ {
ctx.Upsert(EVENTS).
SetInt64(EVENTS.SENSOR, int64(i)).
SetTimeUUID(EVENTS.TIMESTAMP, gocql.TimeUUID()).
SetFloat32(EVENTS.TEMPERATURE, 19.8).
SetInt32(EVENTS.PRESSURE, 357).
Batch(batch)
if i%batchSize == 0 {
if err := session.ExecuteBatch(batch); err != nil {
log.Fatalf("Could not execute batch: %v", err)
os.Exit(1)
}
batch = gocql.NewBatch(gocql.LoggedBatch)
}
}
err := session.ExecuteBatch(batch)
if err != nil {
log.Fatalf("Could not execute batch: %v", err)
os.Exit(1)
}
query, err := ctx.Select().From(EVENTS).Prepare(session)
if err != nil {
log.Fatalf("Could not prepare query: %v", err)
os.Exit(1)
}
query.PageSize(100)
iter := query.Iter()
count := 0
MapEvents(iter, func(e Events) (bool, error) {
count++
return true, nil
})
if err := iter.Close(); err != nil {
log.Fatalf("Could not close iterator: %v", err)
os.Exit(1)
}
if count == events {
result = "PASSED"
}
os.Stdout.WriteString(result)
}
func main() {
session := integration.TestSession("127.0.0.1", "cqlc")
integration.Truncate(session, FIRST_TIMELINE)
integration.Truncate(session, SECOND_TIMELINE)
result := "FAILED"
timestamp := gocql.TimeUUID()
first := FirstTimeline{
When: timestamp,
Tag: "foobar",
}
second := SecondTimeline{
When: timestamp,
Latitude: 50.12,
Longitude: 0.87,
}
ctx := cqlc.NewContext()
err := ctx.Store(FIRST_TIMELINE.Bind(first)).Exec(session)
err = ctx.Store(SECOND_TIMELINE.Bind(second)).Exec(session)
if err != nil {
log.Fatalf("Could not execute upsert: %v", err)
os.Exit(1)
}
var tag string
var latitude float32
f1, err := fetchOne(ctx, session, FIRST_TIMELINE, timestamp, FIRST_TIMELINE.TAG.To(&tag))
f2, err := fetchOne(ctx, session, SECOND_TIMELINE, timestamp, SECOND_TIMELINE.LATITUDE.To(&latitude))
if err != nil {
log.Fatalf("Could not execute select: %v", err)
os.Exit(1)
}
if f1 && f2 && tag == "foobar" && math.Float32bits(latitude) == math.Float32bits(50.12) {
// TODO Implement a FROM binding
t := "bar"
l := float32(72.34)
err = upsert(ctx, session, FIRST_TIMELINE, timestamp, FIRST_TIMELINE.TAG.To(&t))
err = upsert(ctx, session, SECOND_TIMELINE, timestamp, SECOND_TIMELINE.LATITUDE.To(&l))
if err != nil {
log.Fatalf("Could not execute upsert: %v", err)
os.Exit(1)
}
f1, err = fetchOne(ctx, session, FIRST_TIMELINE, timestamp, FIRST_TIMELINE.TAG.To(&tag))
f2, err = fetchOne(ctx, session, SECOND_TIMELINE, timestamp, SECOND_TIMELINE.LATITUDE.To(&latitude))
if err != nil {
log.Fatalf("Could not execute select: %v", err)
os.Exit(1)
}
if f1 && f2 && tag == t && math.Float32bits(latitude) == math.Float32bits(l) {
err = deleteByTimestamp(ctx, session, FIRST_TIMELINE, timestamp)
err = deleteByTimestamp(ctx, session, SECOND_TIMELINE, timestamp)
if err != nil {
log.Fatalf("Could not execute delete: %v", err)
os.Exit(1)
}
var tag string
var latitude float32
f1, err = fetchOne(ctx, session, FIRST_TIMELINE, timestamp, FIRST_TIMELINE.TAG.To(&tag))
f2, err = fetchOne(ctx, session, SECOND_TIMELINE, timestamp, SECOND_TIMELINE.LATITUDE.To(&latitude))
if err != nil {
log.Fatalf("Could not execute select: %v", err)
os.Exit(1)
}
if !f1 && !f2 && tag == "" && latitude == 0.0 {
result = "PASSED"
} else {
result = fmt.Sprintf("After delete - Tag was: %s; Latitude was %f", tag, latitude)
}
} else {
result = fmt.Sprintf("After upsert - Tag was: %s; Latitude was %f", tag, latitude)
}
} else {
result = fmt.Sprintf("Before delete - Tag was: %s; Latitude was %f", tag, latitude)
}
os.Stdout.WriteString(result)
}
func main() {
session := integration.TestSession("127.0.0.1", "cqlc")
integration.Truncate(session, BASIC)
result := "FAILED"
ctx := cqlc.NewContext()
basic := Basic{
Id: "x",
Int32Column: 999,
Int64Column: 1 << 55,
AsciiColumn: "do-re-me",
TimestampColumn: time.Date(1999, time.December, 31, 23, 59, 59, 59, time.UTC), // Keep it simple for reflect.DeepEqual
BooleanColumn: true,
TextColumn: "ipso",
VarcharColumn: "lorem",
FloatColumn: math.MaxFloat32,
DoubleColumn: math.MaxFloat64,
DecimalColumn: inf.NewDec(1, 9),
TimeuuidColumn: gocql.TimeUUID(),
MapColumn: map[string]string{"baz": "quux"},
ArrayColumn: []string{"baz", "quux"},
}
err := ctx.Store(BASIC.Bind(basic)).Exec(session)
if err != nil {
log.Fatalf("Could not bind data: %v", err)
os.Exit(1)
}
var int32Column int32
var decimalColumn *inf.Dec
found, err := ctx.Select().
From(BASIC).
Where(BASIC.ID.Eq("x")).
Bind(BASIC.INT32_COLUMN.To(&int32Column), BASIC.DECIMAL_COLUMN.To(&decimalColumn)).
FetchOne(session)
if err != nil {
log.Fatalf("Could not bind data: %v", err)
os.Exit(1)
}
if err != nil {
log.Fatalf("Could not bind data: %v", err)
os.Exit(1)
}
if int32Column == 999 && reflect.DeepEqual(decimalColumn, basic.DecimalColumn) && found {
found, err := ctx.Select().
From(BASIC).
Where(BASIC.ID.Eq("y")).
Bind(BASIC.INT32_COLUMN.To(&int32Column), BASIC.DECIMAL_COLUMN.To(&decimalColumn)).
FetchOne(session)
if err != nil {
log.Fatalf("Could not bind data: %v", err)
os.Exit(1)
}
if !found {
result = "PASSED"
}
} else {
result = fmt.Sprintf("int32Column: %d, decimalColumn %v", int32Column, decimalColumn)
}
os.Stdout.WriteString(result)
}