func (b *namespaceKeyspace) Count() (int64, errors.Error) {
namespaceIds, excp := b.namespace.store.actualStore.NamespaceIds()
if excp == nil {
return int64(len(namespaceIds)), nil
}
return 0, errors.NewSystemDatastoreError(excp, "")
}
func (pi *keyspaceIndex) Scan(span *datastore.Span, distinct bool, limit int64,
cons datastore.ScanConsistency, vector timestamp.Vector, conn *datastore.IndexConnection) {
defer close(conn.EntryChannel())
val := ""
a := span.Seek[0].Actual()
switch a := a.(type) {
case string:
val = a
default:
conn.Error(errors.NewSystemDatastoreError(nil, fmt.Sprintf("Invalid seek value %v of type %T.", a, a)))
return
}
ids := strings.SplitN(val, "/", 2)
if len(ids) != 2 {
return
}
namespace, _ := pi.keyspace.namespace.store.actualStore.NamespaceById(ids[0])
if namespace == nil {
return
}
keyspace, _ := namespace.KeyspaceById(ids[1])
if keyspace != nil {
entry := datastore.IndexEntry{PrimaryKey: fmt.Sprintf("%s/%s", namespace.Id(), keyspace.Id())}
conn.EntryChannel() <- &entry
}
}
func (b *storeKeyspace) fetchOne(key string) (value.AnnotatedValue, errors.Error) {
if key == b.namespace.store.actualStore.Id() {
doc := value.NewAnnotatedValue(map[string]interface{}{
"id": b.namespace.store.actualStore.Id(),
"url": b.namespace.store.actualStore.URL(),
})
return doc, nil
}
return nil, errors.NewSystemDatastoreError(nil, "Key Not Found "+key)
}
func (b *keyspaceKeyspace) Count() (int64, errors.Error) {
count := int64(0)
namespaceIds, excp := b.namespace.store.actualStore.NamespaceIds()
if excp == nil {
for _, namespaceId := range namespaceIds {
namespace, excp := b.namespace.store.actualStore.NamespaceById(namespaceId)
if excp == nil {
keyspaceIds, excp := namespace.KeyspaceIds()
if excp == nil {
count += int64(len(keyspaceIds))
} else {
return 0, errors.NewSystemDatastoreError(excp, "")
}
} else {
return 0, errors.NewSystemDatastoreError(excp, "")
}
}
return count, nil
}
return 0, errors.NewSystemDatastoreError(excp, "")
}
func (b *namespaceKeyspace) fetchOne(key string) (value.AnnotatedValue, errors.Error) {
namespace, excp := b.namespace.store.actualStore.NamespaceById(key)
if namespace != nil {
doc := value.NewAnnotatedValue(map[string]interface{}{
"id": namespace.Id(),
"name": namespace.Name(),
"datastore_id": b.namespace.store.actualStore.Id(),
})
return doc, nil
}
return nil, errors.NewSystemDatastoreError(excp, "Key Not Found "+key)
}
func (pi *indexIndex) ScanEntries(limit int64, cons datastore.ScanConsistency,
vector timestamp.Vector, conn *datastore.IndexConnection) {
defer close(conn.EntryChannel())
// eliminate duplicate keys
keys := make(map[string]string, 64)
actualStore := pi.keyspace.namespace.store.actualStore
namespaceIds, err := actualStore.NamespaceIds()
if err == nil {
for _, namespaceId := range namespaceIds {
namespace, err := actualStore.NamespaceById(namespaceId)
if err == nil {
keyspaceIds, err := namespace.KeyspaceIds()
if err == nil {
for _, keyspaceId := range keyspaceIds {
keyspace, err := namespace.KeyspaceById(keyspaceId)
if err == nil {
indexers, err := keyspace.Indexers()
if err == nil {
for _, indexer := range indexers {
err = indexer.Refresh()
if err != nil {
conn.Error(errors.NewSystemDatastoreError(err, ""))
return
}
indexIds, err := indexer.IndexIds()
if err == nil {
for _, indexId := range indexIds {
key := fmt.Sprintf("%s/%s/%s", namespaceId, keyspaceId, indexId)
keys[key] = key
}
}
}
}
}
}
}
}
}
}
for k, _ := range keys {
entry := datastore.IndexEntry{PrimaryKey: k}
conn.EntryChannel() <- &entry
}
}
func (b *indexKeyspace) Count() (int64, errors.Error) {
count := int64(0)
namespaceIds, excp := b.namespace.store.actualStore.NamespaceIds()
if excp == nil {
for _, namespaceId := range namespaceIds {
namespace, excp := b.namespace.store.actualStore.NamespaceById(namespaceId)
if excp == nil {
keyspaceIds, excp := namespace.KeyspaceIds()
if excp == nil {
for _, keyspaceId := range keyspaceIds {
keyspace, excp := namespace.KeyspaceById(keyspaceId)
if excp == nil {
indexers, excp := keyspace.Indexers()
if excp == nil {
for _, indexer := range indexers {
excp = indexer.Refresh()
if excp != nil {
return 0, errors.NewSystemDatastoreError(excp, "")
}
indexIds, excp := indexer.IndexIds()
if excp == nil {
count += int64(len(indexIds))
} else {
return 0, errors.NewSystemDatastoreError(excp, "")
}
}
} else {
return 0, errors.NewSystemDatastoreError(excp, "")
}
} else {
return 0, errors.NewSystemDatastoreError(excp, "")
}
}
} else {
return 0, errors.NewSystemDatastoreError(excp, "")
}
} else {
return 0, errors.NewSystemDatastoreError(excp, "")
}
}
return count, nil
}
return 0, errors.NewSystemDatastoreError(excp, "")
}
func (pi *storeIndex) Scan(span *datastore.Span, distinct bool, limit int64,
cons datastore.ScanConsistency, vector timestamp.Vector, conn *datastore.IndexConnection) {
defer close(conn.EntryChannel())
val := ""
a := span.Seek[0].Actual()
switch a := a.(type) {
case string:
val = a
default:
conn.Error(errors.NewSystemDatastoreError(nil, fmt.Sprintf("Invalid seek value %v of type %T.", a, a)))
return
}
if strings.EqualFold(val, pi.keyspace.namespace.store.actualStore.Id()) {
entry := datastore.IndexEntry{PrimaryKey: pi.keyspace.namespace.store.actualStore.Id()}
conn.EntryChannel() <- &entry
}
}
func (b *dualKeyspace) Delete(deletes []string) ([]string, errors.Error) {
return nil, errors.NewSystemDatastoreError(nil, "Mutations not allowed on system:dual.")
}
func (b *dualKeyspace) Upsert(upserts []datastore.Pair) ([]datastore.Pair, errors.Error) {
return nil, errors.NewSystemDatastoreError(nil, "Mutations not allowed on system:dual.")
}