diff --git a/api.go b/api.go
index 88a1e6be0..4483e0db9 100644
--- a/api.go
+++ b/api.go
@@ -1672,7 +1672,7 @@ func (api *API) FindIndexKeys(ctx context.Context, index string, keys ...string)
 func (api *API) FindFieldKeys(ctx context.Context, index, field string, keys ...string) (map[string]uint64, error) {
 	f := api.holder.Field(index, field)
 	if f == nil {
-		return nil, newNotFoundError(ErrFieldNotFound, field)
+		return nil, errors.Wrapf(ErrFieldNotFound, "finding keys for field %q", field)
 	}
 	return api.cluster.findFieldKeys(ctx, f, keys...)
 }
@@ -1688,7 +1688,7 @@ func (api *API) CreateIndexKeys(ctx context.Context, index string, keys ...strin
 func (api *API) CreateFieldKeys(ctx context.Context, index, field string, keys ...string) (map[string]uint64, error) {
 	f := api.holder.Field(index, field)
 	if f == nil {
-		return nil, newNotFoundError(ErrFieldNotFound, field)
+		return nil, errors.Wrapf(ErrFieldNotFound, "finding keys for field %q", field)
 	}
 	return api.cluster.createFieldKeys(ctx, f, keys...)
 }
diff --git a/cluster.go b/cluster.go
index 16db2e8e0..246f71e74 100644
--- a/cluster.go
+++ b/cluster.go
@@ -2628,7 +2628,7 @@ func (c *cluster) findIndexKeys(ctx context.Context, indexName string, keys ...s
 	// Split keys by partition.
 	keysByPartition := make(map[int][]string, c.partitionN)
 	for _, key := range keys {
-		partitionID := c.Topology.KeyPartition(indexName, key)
+		partitionID := c.keyPartition(indexName, key)
 		keysByPartition[partitionID] = append(keysByPartition[partitionID], key)
 	}
 
@@ -2728,7 +2728,7 @@ func (c *cluster) createIndexKeys(ctx context.Context, indexName string, keys ..
 	// Split keys by partition.
 	keysByPartition := make(map[int][]string, c.partitionN)
 	for _, key := range keys {
-		partitionID := c.Topology.KeyPartition(indexName, key)
+		partitionID := c.keyPartition(indexName, key)
 		keysByPartition[partitionID] = append(keysByPartition[partitionID], key)
 	}
 
diff --git a/executor.go b/executor.go
index 412e9a935..823e98b36 100644
--- a/executor.go
+++ b/executor.go
@@ -485,7 +485,7 @@ func (e *executor) execute(ctx context.Context, index string, q *pql.Query, shar
 
 	// Optimize handling for bulk attribute insertion.
 	if hasOnlySetRowAttrs(q.Calls) {
-		return e.executeBulkSetRowAttrs(ctx, index, q.Calls, opt)
+		return e.executeBulkSetRowAttrs(ctx, index, q.Calls, opt, colTranslations, rowTranslations)
 	}
 
 	// Execute each call serially.
@@ -780,19 +780,9 @@ func (e *executor) executeFieldValueCall(ctx context.Context, index string, c *p
 		return ValCount{}, ErrFieldNotFound
 	}
 
-	var colID uint64
-	if key, ok := colKey.(string); ok && idx.Keys() {
-		id, err := e.Cluster.translateIndexKey(ctx, index, key, false)
-		if err != nil {
-			return ValCount{}, errors.Wrap(err, "getting column id")
-		}
-		colID = id
-	} else {
-		id, ok, err := c.UintArg("column")
-		if !ok || err != nil {
-			return ValCount{}, errors.Wrap(err, "getting column argument")
-		}
-		colID = id
+	colID, ok, err := c.UintArg("column")
+	if !ok || err != nil {
+		return ValCount{}, errors.Wrap(err, "getting column argument")
 	}
 
 	shard := colID / ShardWidth
@@ -3188,19 +3178,7 @@ func (e *executor) executeSetRow(ctx context.Context, indexName string, c *pql.C
 	}
 	field := e.Holder.Field(indexName, fieldName)
 	if field == nil {
-		// Find index.
-		index := e.Holder.Index(indexName)
-		if index == nil {
-			return false, newNotFoundError(ErrIndexNotFound)
-		}
-
-		// Create field.
-		field, err = index.CreateField(fieldName, OptFieldTypeSet(CacheTypeNone, 0))
-		if err != nil {
-			// We wrap these because we want to indicate that it wasn't found,
-			// but also the problem we encountered trying to create it.
-			return false, newNotFoundError(errors.Wrap(err, "creating field"))
-		}
+		return false, errors.Wrapf(ErrFieldNotFound, "field %q", field)
 	}
 	if field.Type() != FieldTypeSet {
 		return false, fmt.Errorf("can't Store() on a %s field", field.Type())
@@ -3543,7 +3521,8 @@ func (e *executor) executeSetRowAttrs(ctx context.Context, index string, c *pql.
 }
 
 // executeBulkSetRowAttrs executes a set of SetRowAttrs() calls.
-func (e *executor) executeBulkSetRowAttrs(ctx context.Context, index string, calls []*pql.Call, opt *execOptions) ([]interface{}, error) {
+
+func (e *executor) executeBulkSetRowAttrs(ctx context.Context, index string, calls []*pql.Call, opt *execOptions, colTranslations map[string]map[string]uint64, rowTranslations map[string]map[string]map[string]uint64) ([]interface{}, error) {
 	span, ctx := tracing.StartSpanFromContext(ctx, "Executor.executeBulkSetRowAttrs")
 	defer span.Finish()
 
@@ -3556,6 +3535,19 @@ func (e *executor) executeBulkSetRowAttrs(ctx context.Context, index string, cal
 			}
 		}
 
+		// Apply call translation.
+		if !opt.Remote {
+			translated, err := e.translateCallNew(c, index, colTranslations, rowTranslations)
+			if err != nil {
+				return nil, errors.Wrap(err, "translating call")
+			}
+			if translated == nil {
+				continue
+			}
+
+			c = translated
+		}
+
 		field, ok := c.Args["_field"].(string)
 		if !ok {
 			return nil, errors.New("SetRowAttrs() field required")
@@ -4153,13 +4145,51 @@ func (e *executor) collectCallKeysNew(dst *keyCollector, c *pql.Call, index stri
 
 	// Handle the field arg.
 	switch c.Name {
-	case "Set", "Store":
+	case "Set":
 		if field, err := c.FieldArg(); err == nil {
 			if arg, ok := c.Args[field].(string); ok {
 				dst.CreateRows(index, field, arg)
 			}
 		}
 
+	case "Store":
+		if field, err := c.FieldArg(); err == nil {
+			idx := e.Holder.Index(index)
+			if idx == nil {
+				return errors.Wrapf(ErrIndexNotFound, "translating store field argument")
+			}
+			f := idx.Field(field)
+			if f == nil {
+				// Create the field.
+				// This is messy, because if a query leading up to the store fails, we will have created the field without executing the store.
+				var keyed bool
+				switch v := c.Args[field].(type) {
+				case string:
+					keyed = true
+				case uint64:
+				case int64:
+					if v < 0 {
+						return errors.Errorf("negative store row ID %d", v)
+					}
+				default:
+					return errors.Errorf("invalid store row identifier: %v of %T", v, v)
+				}
+				opts := []FieldOption{OptFieldTypeSet(CacheTypeNone, 0)}
+				if keyed {
+					opts = append(opts, OptFieldKeys())
+				}
+				f, err = idx.CreateField(field, opts...)
+				if err != nil {
+					// We wrap these because we want to indicate that it wasn't found,
+					// but also the problem we encountered trying to create it.
+					return newNotFoundError(errors.Wrapf(err, "creating field %q", field))
+				}
+			}
+			if arg, ok := c.Args[field].(string); ok {
+				dst.CreateRows(index, field, arg)
+			}
+		}
+
 	case "Clear", "Row", "Range", "ClearRow":
 		if field, err := c.FieldArg(); err == nil {
 			switch arg := c.Args[field].(type) {
@@ -4186,6 +4216,25 @@ func (e *executor) collectCallKeysNew(dst *keyCollector, c *pql.Call, index stri
 		}
 	}
 
+	// Handle _row.
+	if row, ok := c.Args["_row"].(string); ok {
+		// Find the field.
+		field, ok, err := c.StringArg("_field")
+		if err != nil {
+			return errors.Wrap(err, "finding field")
+		}
+		if !ok {
+			return errors.Wrap(ErrFieldNotFound, "finding field for _row argument")
+		}
+
+		switch c.Name {
+		case "SetRowAttrs":
+			dst.CreateRows(index, field, row)
+		default:
+			dst.FindRows(index, field, row)
+		}
+	}
+
 	// Handle queries that need a "column" argument.
 	switch c.Name {
 	case "Rows", "GroupBy", "FieldValue", "IncludesColumn":
@@ -4404,6 +4453,34 @@ func (e *executor) translateCallNew(c *pql.Call, index string, columnKeys map[st
 		}
 	}
 
+	// Handle _row.
+	if row, ok := c.Args["_row"].(string); ok {
+		// Find the field.
+		var field string
+		if f, ok, err := c.StringArg("_field"); err != nil {
+			return nil, errors.Wrap(err, "finding field")
+		} else if ok {
+			field = f
+		} else if f, ok, err := c.StringArg("field"); err != nil {
+			return nil, errors.Wrap(err, "finding field")
+		} else if ok {
+			field = f
+		} else {
+			return nil, errors.New("missing field")
+		}
+
+		if translation, ok := indexRows[field][row]; ok {
+			c.Args["_row"] = translation
+		} else {
+			switch c.Name {
+			case "SetRowAttrs":
+				return nil, errors.Errorf("row key missing in %q", c.String())
+			default:
+				return e.callZero(c), nil
+			}
+		}
+	}
+
 	// Handle queries that need a "column" argument.
 	switch c.Name {
 	case "Rows", "GroupBy", "FieldValue", "IncludesColumn":
diff --git a/pql/ast.go b/pql/ast.go
index e93a2aaf5..087a04120 100644
--- a/pql/ast.go
+++ b/pql/ast.go
@@ -662,6 +662,19 @@ func (c *Call) UintSliceArg(key string) ([]uint64, bool, error) {
 	}
 }
 
+func (c *Call) StringArg(key string) (string, bool, error) {
+	val, ok := c.Args[key]
+	if !ok {
+		return "", false, nil
+	}
+	switch tval := val.(type) {
+	case string:
+		return tval, true, nil
+	default:
+		return "", true, fmt.Errorf("unexpected type %T in StringArg, val %v", tval, tval)
+	}
+}
+
 // CallArg is for reading the value at key from call.Args as a Call. If the
 // key is not in Call.Args, the value of the returned value will be nil, and
 // the error will be nil. An error is returned if the value is not a Call.
diff --git a/translator_test.go b/translator_test.go
index 0fb6cac54..cb48ec7bf 100644
--- a/translator_test.go
+++ b/translator_test.go
@@ -21,7 +21,6 @@ import (
 	"io"
 	"reflect"
 	"testing"
-	"time"
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/pilosa/pilosa/v2"
@@ -31,7 +30,6 @@ import (
 	"github.com/pilosa/pilosa/v2/server"
 	"github.com/pilosa/pilosa/v2/test"
 	"github.com/pkg/errors"
-	"golang.org/x/sync/errgroup"
 )
 
 func TestInMemTranslateStore_TranslateKey(t *testing.T) {
@@ -474,6 +472,8 @@ func TestTranslation_Coordinator(t *testing.T) {
 	})
 }
 
+/*
+// Unfortunately. . . this test depends on tons of changes within the test package.
 func TestTranslation_Cluster_CreateFind(t *testing.T) {
 	c := test.MustRunCluster(t, 3)
 	defer c.Close()
@@ -722,3 +722,4 @@ func TestTranslation_Cluster_CreateFind(t *testing.T) {
 		}
 	})
 }
+*/