// Helper function to perform a primary index scan on the given keyspace. Returns a map of
// all primary key names.
func doPrimaryIndexScan(t *testing.T, b datastore.Keyspace) (m map[string]bool, excp errors.Error) {
conn := datastore.NewIndexConnection(&testingContext{t})
m = map[string]bool{}
nitems, excp := b.Count()
if excp != nil {
t.Fatalf("failed to get keyspace count")
return
}
indexers, excp := b.Indexers()
if excp != nil {
t.Fatalf("failed to retrieve indexers")
return
}
pindexes, excp := indexers[0].PrimaryIndexes()
if excp != nil || len(pindexes) < 1 {
t.Fatalf("failed to retrieve primary indexes")
return
}
idx := pindexes[0]
go idx.ScanEntries(nitems, datastore.UNBOUNDED, nil, conn)
for {
v, ok := <-conn.EntryChannel()
if !ok {
// Channel closed => Scan complete
return
}
m[v.PrimaryKey] = true
}
}
func (this *spanScan) RunOnce(context *Context, parent value.Value) {
this.once.Do(func() {
defer context.Recover() // Recover from any panic
defer close(this.itemChannel) // Broadcast that I have stopped
defer this.notify() // Notify that I have stopped
conn := datastore.NewIndexConnection(context)
defer notifyConn(conn) // Notify index that I have stopped
go this.scan(context, conn)
var entry *datastore.IndexEntry
ok := true
for ok {
select {
case <-this.stopChannel:
return
default:
}
select {
case entry, ok = <-conn.EntryChannel():
if ok {
cv := value.NewScopeValue(make(map[string]interface{}), parent)
av := value.NewAnnotatedValue(cv)
av.SetAttachment("meta", map[string]interface{}{"id": entry.PrimaryKey})
ok = this.sendItem(av)
}
case <-this.stopChannel:
return
}
}
})
}
func (this *PrimaryScan) scanPrimary(context *Context, parent value.Value) {
conn := datastore.NewIndexConnection(context)
defer notifyConn(conn) // Notify index that I have stopped
go this.scanEntries(context, conn)
var entry *datastore.IndexEntry
ok := true
for ok {
select {
case <-this.stopChannel:
return
default:
}
select {
case entry, ok = <-conn.EntryChannel():
if ok {
cv := value.NewScopeValue(make(map[string]interface{}), parent)
av := value.NewAnnotatedValue(cv)
av.SetAttachment("meta", map[string]interface{}{"id": entry.PrimaryKey})
ok = this.sendItem(av)
}
case <-this.stopChannel:
return
}
}
}
func Test2iScanEntries(t *testing.T) {
c.LogIgnore()
//c.SetLogLevel(c.LogLevelDebug)
conn := datastore.NewIndexConnection(nil)
entrych := conn.EntryChannel()
quitch := conn.StopChannel()
go index.ScanEntries(10000, conn)
count := 0
loop:
for {
select {
case _, ok := <-entrych:
if !ok {
break loop
}
count++
case <-quitch:
break loop
}
}
if count != 20000 {
t.Fatal("failed ScanEntries() - ", count)
}
}
func Test2iScanRange(t *testing.T) {
c.LogIgnore()
//c.SetLogLevel(c.LogLevelDebug)
low, high := value.NewValue("aaaa"), value.NewValue("zzzz")
span := &datastore.Span{
Range: &datastore.Range{
Low: value.Values{low},
High: value.Values{high},
Inclusion: datastore.BOTH,
},
}
conn := datastore.NewIndexConnection(nil)
entrych := conn.EntryChannel()
quitch := conn.StopChannel()
go index.Scan(span, false, 10000, conn)
count := 0
loop:
for {
select {
case _, ok := <-entrych:
if !ok {
break loop
}
count++
case <-quitch:
break loop
}
}
if count != 20000 {
t.Fatal("failed ScanRange() - ", count)
}
}
// Helper function to scan the primary index of given keyspace with given span
func doIndexScan(t *testing.T, b datastore.Keyspace, span *datastore.Span) (
e []*datastore.IndexEntry, excp errors.Error) {
conn := datastore.NewIndexConnection(&testingContext{t})
e = []*datastore.IndexEntry{}
nitems, excp := b.Count()
if excp != nil {
t.Fatalf("failed to get keyspace count")
return
}
indexers, excp := b.Indexers()
if excp != nil {
t.Fatalf("failed to retrieve indexers")
return
}
idx, excp := indexers[0].IndexByName("#primary")
if excp != nil {
t.Fatalf("failed to retrieve primary index")
return
}
go idx.Scan(span, false, nitems, datastore.UNBOUNDED, nil, conn)
for {
entry, ok := <-conn.EntryChannel()
if !ok {
return
}
e = append(e, entry)
}
return
}
func TestFile(t *testing.T) {
store, err := NewDatastore("../../test/json")
if err != nil {
t.Fatalf("failed to create store: %v", err)
}
namespaceIds, err := store.NamespaceIds()
if err != nil {
t.Errorf("failed to get namespace ids: %v", err)
}
if len(namespaceIds) != 1 || namespaceIds[0] != "default" {
t.Errorf("expected 1 namespace id'd default")
}
namespace, err := store.NamespaceById("default")
if err != nil {
t.Errorf("failed to get namespace: %v", err)
}
namespaceNames, err := store.NamespaceNames()
if err != nil {
t.Errorf("failed to get namespace names: %v", err)
}
if len(namespaceNames) != 1 || namespaceNames[0] != "default" {
t.Errorf("expected 1 namespace named json")
}
fmt.Printf("Found namespaces %v", namespaceNames)
namespace, err = store.NamespaceByName("default")
if err != nil {
t.Fatalf("failed to get namespace: %v", err)
}
ks, err := namespace.KeyspaceIds()
if err != nil {
t.Errorf("failed to get keyspace ids: %v", err)
}
fmt.Printf("Keyspace ids %v", ks)
keyspace, err := namespace.KeyspaceById("contacts")
if err != nil {
t.Errorf("failed to get keyspace by id: contacts")
}
_, err = namespace.KeyspaceNames()
if err != nil {
t.Errorf("failed to get keyspace names: %v", err)
}
keyspace, err = namespace.KeyspaceByName("contacts")
if err != nil {
t.Fatalf("failed to get keyspace by name: contacts")
}
indexers, err := keyspace.Indexers()
if err != nil {
t.Errorf("failed to get indexers")
}
indexes, err := indexers[0].Indexes()
if err != nil {
t.Errorf("failed to get indexes")
}
if len(indexes) < 1 {
t.Errorf("Expected at least 1 index for keyspace")
}
pindexes, err := indexers[0].PrimaryIndexes()
if err != nil {
t.Errorf("failed to get primary indexes")
}
if len(pindexes) < 1 {
t.Errorf("Expected at least 1 primary index for keyspace")
}
index := pindexes[0]
context := &testingContext{t}
conn := datastore.NewIndexConnection(context)
go index.ScanEntries(math.MaxInt64, datastore.UNBOUNDED, nil, conn)
ok := true
for ok {
entry, ok := <-conn.EntryChannel()
if ok {
fmt.Printf("\nScanned %s", entry.PrimaryKey)
} else {
break
}
}
freds, err := keyspace.Fetch([]string{"fred"})
if err != nil || len(freds) == 0 {
t.Errorf("failed to fetch fred: %v", err)
}
// DML test cases
fred := freds[0].Value
var dmlKey datastore.Pair
dmlKey.Key = "fred2"
dmlKey.Value = fred
_, err = keyspace.Insert([]datastore.Pair{dmlKey})
if err != nil {
t.Errorf("failed to insert fred2: %v", err)
}
_, err = keyspace.Update([]datastore.Pair{dmlKey})
if err != nil {
t.Errorf("failed to insert fred2: %v", err)
}
_, err = keyspace.Upsert([]datastore.Pair{dmlKey})
if err != nil {
t.Errorf("failed to insert fred2: %v", err)
}
dmlKey.Key = "fred3"
_, err = keyspace.Upsert([]datastore.Pair{dmlKey})
if err != nil {
t.Errorf("failed to insert fred2: %v", err)
}
// negative cases
_, err = keyspace.Insert([]datastore.Pair{dmlKey})
if err == nil {
t.Errorf("Insert should not have succeeded for fred2")
}
// delete all the freds
deleted, err := keyspace.Delete([]string{"fred2", "fred3"})
if err != nil && len(deleted) != 2 {
fmt.Printf("Warning: Failed to delete. Error %v", err)
}
_, err = keyspace.Update([]datastore.Pair{dmlKey})
if err == nil {
t.Errorf("Update should have failed. Key fred3 doesn't exist")
}
// finally upsert the key. this should work
_, err = keyspace.Upsert([]datastore.Pair{dmlKey})
if err != nil {
t.Errorf("failed to insert fred2: %v", err)
}
// some deletes should fail
deleted, err = keyspace.Delete([]string{"fred2", "fred3"})
if len(deleted) != 1 && deleted[0] != "fred2" {
t.Errorf("failed to delete fred2: %v, #deleted=%d", deleted, len(deleted))
}
}
func TestServer(t *testing.T) {
logger, _ := log_resolver.NewLogger("golog")
if logger == nil {
t.Fatalf("Invalid logger")
}
logging.SetLogger(logger)
site, err := NewDatastore(TEST_URL)
if err != nil {
t.Skipf("SKIPPING TEST: %v", err)
}
namespaceNames, err := site.NamespaceNames()
if err != nil {
t.Fatalf("Failed to get Namespace names . error %v", err)
}
fmt.Printf("Namespaces in this instance %v", namespaceNames)
namespace, err := site.NamespaceByName("default")
if err != nil {
t.Fatalf("Namespace default not found, error %v", err)
}
keyspaceNames, err := namespace.KeyspaceNames()
if err != nil {
t.Fatalf(" Cannot fetch keyspaces names. error %v", err)
}
fmt.Printf("Keyspaces in this namespace %v", keyspaceNames)
//connect to beer-sample
ks, err := namespace.KeyspaceByName("beer-sample")
if err != nil {
t.Fatalf(" Cannot connect to beer-sample. Error %v", err)
return
}
indexer, err := ks.Indexer(datastore.VIEW)
if err != nil {
fmt.Printf("No indexers found")
return
}
// try create a primary index
index, err := indexer.CreatePrimaryIndex("#primary", nil)
if err != nil {
// keep going. maybe index already exists
fmt.Printf(" Cannot create a primary index on bucket. Error %v", err)
} else {
fmt.Printf("primary index created %v", index)
}
pair, err := ks.Fetch([]string{"357", "aass_brewery"})
if err != nil {
t.Fatalf(" Cannot fetch keys error %v", err)
}
fmt.Printf("Keys fetched %v", pair)
insertKey := datastore.Pair{Key: "testBeerKey", Value: value.NewValue(("This is a random test key-value"))}
_, err = ks.Insert([]datastore.Pair{insertKey})
if err != nil {
t.Fatalf("Cannot insert key %v", insertKey)
}
deleted, err := ks.Delete([]string{insertKey.Key})
if err != nil || (len(deleted) != 1 && deleted[0] != insertKey.Key) {
t.Fatalf("Failed to delete %v", err)
}
pi, err := indexer.PrimaryIndexes()
if err != nil || len(pi) < 1 {
fmt.Printf("No primary index found")
return
}
//fmt.Printf(" got primary index %s", pi.name)
conn := datastore.NewIndexConnection(nil)
go pi[0].ScanEntries(math.MaxInt64, datastore.UNBOUNDED, nil, conn)
var entry *datastore.IndexEntry
ok := true
for ok {
select {
case entry, ok = <-conn.EntryChannel():
if ok {
fmt.Printf("\n primary key %v", entry.PrimaryKey)
}
}
}
}