Remove copy constructors.

21 files changed, 119 insertions, 226 deletions

diff --git a/document/src/tests/documentselectparsertest.cpp b/document/src/tests/documentselectparsertest.cpp
index a447df1044e..70ebd9bd7a2 100644
--- a/document/src/tests/documentselectparsertest.cpp
+++ b/document/src/tests/documentselectparsertest.cpp
@@ -139,9 +139,9 @@ DocumentUpdate::SP DocumentSelectParserTest::createUpdate(
     const DocumentType* type = _repo->getDocumentType(doctype);
     auto doc = std::make_shared<DocumentUpdate>(*_repo, *type, DocumentId(id));
     doc->addUpdate(FieldUpdate(doc->getType().getField("headerval"))
-                      .addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(hint))));
+                      .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(hint))));
     doc->addUpdate(FieldUpdate(doc->getType().getField("hstringval"))
-                      .addUpdate(std::make_unique<AssignValueUpdate>(StringFieldValue(hstr))));
+                      .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<StringFieldValue>(hstr))));
     return doc;
 }
 
diff --git a/document/src/tests/documentupdatetestcase.cpp b/document/src/tests/documentupdatetestcase.cpp
index 93ab1c370c5..27a9791b95c 100644
--- a/document/src/tests/documentupdatetestcase.cpp
+++ b/document/src/tests/documentupdatetestcase.cpp
@@ -120,13 +120,13 @@ TEST(DocumentUpdateTest, testSimpleUsage)
 
         // Test that primitive value updates can be serialized
     testRoundtripSerialize(ClearValueUpdate(), *DataType::INT);
-    testRoundtripSerialize(AssignValueUpdate(IntFieldValue(1)), *DataType::INT);
+    testRoundtripSerialize(AssignValueUpdate(std::make_unique<IntFieldValue>(1)), *DataType::INT);
     testRoundtripSerialize(ArithmeticValueUpdate(ArithmeticValueUpdate::Div, 4.3), *DataType::FLOAT);
-    testRoundtripSerialize(AddValueUpdate(IntFieldValue(1), 4), *arrayType);
-    testRoundtripSerialize(RemoveValueUpdate(IntFieldValue(1)), *arrayType);
+    testRoundtripSerialize(AddValueUpdate(std::make_unique<IntFieldValue>(1), 4), *arrayType);
+    testRoundtripSerialize(RemoveValueUpdate(std::make_unique<IntFieldValue>(1)), *arrayType);
 
     FieldUpdate fieldUpdate(docType->getField("intf"));
-    fieldUpdate.addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(1)));
+    fieldUpdate.addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(1)));
     nbostream stream = serialize(fieldUpdate);
     FieldUpdate fieldUpdateCopy(repo, *docType, stream);
     EXPECT_EQ(fieldUpdate, fieldUpdateCopy);
@@ -158,7 +158,7 @@ TEST(DocumentUpdateTest, testSimpleUsage)
     {
         Document updated(doc);
         DocumentUpdate upd(repo, *docType, DocumentId("id:ns:test::1"));
-        upd.addUpdate(FieldUpdate(docType->getField("intf")).addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(15))));
+        upd.addUpdate(FieldUpdate(docType->getField("intf")).addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(15))));
         upd.applyTo(updated);
         EXPECT_NE(doc, updated);
         EXPECT_EQ(15, updated.getValue("intf")->getAsInt());
@@ -174,7 +174,7 @@ TEST(DocumentUpdateTest, testSimpleUsage)
     {
         Document updated(doc);
         DocumentUpdate upd(repo, *docType, DocumentId("id:ns:test::1"));
-        upd.addUpdate(FieldUpdate(docType->getField("intarr")).addUpdate(std::make_unique<AddValueUpdate>(IntFieldValue(4))));
+        upd.addUpdate(FieldUpdate(docType->getField("intarr")).addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(4))));
         upd.applyTo(updated);
         EXPECT_NE(doc, updated);
         std::unique_ptr<ArrayFieldValue> val(dynamic_cast<ArrayFieldValue*>(updated.getValue("intarr").release()));
@@ -184,7 +184,7 @@ TEST(DocumentUpdateTest, testSimpleUsage)
     {
         Document updated(doc);
         DocumentUpdate upd(repo, *docType, DocumentId("id:ns:test::1"));
-        upd.addUpdate(FieldUpdate(docType->getField("intarr")).addUpdate(std::make_unique<RemoveValueUpdate>(IntFieldValue(3))));
+        upd.addUpdate(FieldUpdate(docType->getField("intarr")).addUpdate(std::make_unique<RemoveValueUpdate>(std::make_unique<IntFieldValue>(3))));
         upd.applyTo(updated);
         EXPECT_NE(doc, updated);
         std::unique_ptr<ArrayFieldValue> val(dynamic_cast<ArrayFieldValue*>(updated.getValue("intarr").release()));
@@ -227,7 +227,7 @@ TEST(DocumentUpdateTest, testUpdateApplySingleValue)
 
     // Apply an update.
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
-        .addUpdate(FieldUpdate(doc->getField("headerval")).addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(9))))
+        .addUpdate(FieldUpdate(doc->getField("headerval")).addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(9))))
         .applyTo(*doc);
     EXPECT_EQ(9, doc->getValue("headerval")->getAsInt());
 }
@@ -240,12 +240,12 @@ TEST(DocumentUpdateTest, testUpdateArray)
     EXPECT_EQ((document::FieldValue*)nullptr, doc->getValue(doc->getField("tags")).get());
 
     // Assign array field.
-    ArrayFieldValue myarray(doc->getType().getField("tags").getDataType());
-    myarray.add(StringFieldValue("foo"));
-	myarray.add(StringFieldValue("bar"));
+    auto myarray = std::make_unique<ArrayFieldValue>(doc->getType().getField("tags").getDataType());
+    myarray->add(StringFieldValue("foo"));
+	myarray->add(StringFieldValue("bar"));
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
-        .addUpdate(FieldUpdate(doc->getField("tags")).addUpdate(std::make_unique<AssignValueUpdate>(myarray)))
+        .addUpdate(FieldUpdate(doc->getField("tags")).addUpdate(std::make_unique<AssignValueUpdate>(std::move(myarray))))
         .applyTo(*doc);
     auto fval1(doc->getAs<ArrayFieldValue>(doc->getField("tags")));
     ASSERT_EQ((size_t) 2, fval1->size());
@@ -255,8 +255,8 @@ TEST(DocumentUpdateTest, testUpdateArray)
     // Append array field
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(doc->getField("tags"))
-                   .addUpdate(std::make_unique<AddValueUpdate>(StringFieldValue("another")))
-                   .addUpdate(std::make_unique<AddValueUpdate>(StringFieldValue("tag"))))
+                   .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<StringFieldValue>("another")))
+                   .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<StringFieldValue>("tag"))))
         .applyTo(*doc);
     std::unique_ptr<ArrayFieldValue>
         fval2(doc->getAs<ArrayFieldValue>(doc->getField("tags")));
@@ -270,15 +270,15 @@ TEST(DocumentUpdateTest, testUpdateArray)
     ASSERT_THROW(
         DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
             .addUpdate(FieldUpdate(doc->getField("tags"))
-                       .addUpdate(std::make_unique<AssignValueUpdate>(StringFieldValue("THROW MEH!"))))
+                       .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<StringFieldValue>("THROW MEH!"))))
             .applyTo(*doc),
         std::exception) << "Expected exception when assigning a string value to an array field.";
 
     // Remove array field.
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(doc->getField("tags"))
-                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue("foo")))
-                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue("tag"))))
+                   .addUpdate(std::make_unique<RemoveValueUpdate>(std::make_unique<StringFieldValue>("foo")))
+                   .addUpdate(std::make_unique<RemoveValueUpdate>(std::make_unique<StringFieldValue>("tag"))))
         .applyTo(*doc);
     auto fval3(doc->getAs<ArrayFieldValue>(doc->getField("tags")));
     ASSERT_EQ((size_t) 2, fval3->size());
@@ -286,27 +286,27 @@ TEST(DocumentUpdateTest, testUpdateArray)
     EXPECT_EQ(std::string("another"), std::string((*fval3)[1].getAsString()));
 
     // Remove array from array.
-    ArrayFieldValue myarray2(doc->getType().getField("tags").getDataType());
-    myarray2.add(StringFieldValue("foo"));
-    myarray2.add(StringFieldValue("bar"));
+    auto myarray2 = std::make_unique<ArrayFieldValue>(doc->getType().getField("tags").getDataType());
+    myarray2->add(StringFieldValue("foo"));
+    myarray2->add(StringFieldValue("bar"));
     ASSERT_THROW(
         DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
             .addUpdate(FieldUpdate(doc->getField("tags"))
-                       .addUpdate(std::make_unique<RemoveValueUpdate>(myarray2)))
+                       .addUpdate(std::make_unique<RemoveValueUpdate>(std::move(myarray2))))
             .applyTo(*doc),
         std::exception) << "Expected exception when removing an array from a string array.";
 }
 
 std::unique_ptr<ValueUpdate>
 createAddUpdate(vespalib::stringref key, int weight) {
-    auto upd = std::make_unique<AddValueUpdate>(StringFieldValue(key));
+    auto upd = std::make_unique<AddValueUpdate>(std::make_unique<StringFieldValue>(key));
     upd->setWeight(weight);
     return upd;
 }
 
 std::unique_ptr<ValueUpdate>
 createAddUpdate(int key, int weight) {
-    auto upd = std::make_unique<AddValueUpdate>(IntFieldValue(key));
+    auto upd = std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(key));
     upd->setWeight(weight);
     return upd;
 }
@@ -320,11 +320,11 @@ TEST(DocumentUpdateTest, testUpdateWeightedSet)
     EXPECT_EQ((FieldValue*) 0, doc->getValue(field).get());
 	
     // Assign weightedset field
-    WeightedSetFieldValue wset(field.getDataType());
-    wset.add(StringFieldValue("foo"), 3);
-    wset.add(StringFieldValue("bar"), 14);
+    auto wset =std::make_unique<WeightedSetFieldValue>(field.getDataType());
+    wset->add(StringFieldValue("foo"), 3);
+    wset->add(StringFieldValue("bar"), 14);
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
-        .addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(wset)))
+        .addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(std::move(wset))))
         .applyTo(*doc);
     auto fval1(doc->getAs<WeightedSetFieldValue>(field));
     ASSERT_EQ((size_t) 2, fval1->size());
@@ -336,12 +336,12 @@ TEST(DocumentUpdateTest, testUpdateWeightedSet)
     EXPECT_EQ(14, fval1->get(StringFieldValue("bar"), 0));
 
     // Do a second assign
-    WeightedSetFieldValue wset2(field.getDataType());
-    wset2.add(StringFieldValue("foo"), 16);
-    wset2.add(StringFieldValue("bar"), 24);
+    auto wset2 = std::make_unique<WeightedSetFieldValue>(field.getDataType());
+    wset2->add(StringFieldValue("foo"), 16);
+    wset2->add(StringFieldValue("bar"), 24);
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field)
-                   .addUpdate(std::make_unique<AssignValueUpdate>(wset2)))
+                   .addUpdate(std::make_unique<AssignValueUpdate>(std::move(wset2))))
         .applyTo(*doc);
     auto fval2(doc->getAs<WeightedSetFieldValue>(field));
     ASSERT_EQ((size_t) 2, fval2->size());
@@ -371,8 +371,8 @@ TEST(DocumentUpdateTest, testUpdateWeightedSet)
     // Remove weighted field
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field)
-                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue("foo")))
-                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue("too"))))
+                   .addUpdate(std::make_unique<RemoveValueUpdate>(std::make_unique<StringFieldValue>("foo")))
+                   .addUpdate(std::make_unique<RemoveValueUpdate>(std::make_unique<StringFieldValue>("too"))))
         .applyTo(*doc);
     auto fval4(doc->getAs<WeightedSetFieldValue>(field));
     ASSERT_EQ((size_t) 1, fval4->size());
@@ -419,7 +419,7 @@ WeightedSetAutoCreateFixture::WeightedSetAutoCreateFixture()
       update(repo, *docType, DocumentId("id:ns:test::1"))
 {
     update.addUpdate(FieldUpdate(field)
-                             .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("foo"),
+                             .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<StringFieldValue>("foo"),
                                                        std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 1))));
 }
 } // anon ns
@@ -457,7 +457,7 @@ TEST(DocumentUpdateTest, testIncrementWithZeroResultWeightIsRemoved)
 {
     WeightedSetAutoCreateFixture fixture;
     fixture.update.addUpdate(FieldUpdate(fixture.field)
-            .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("baz"),
+            .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<StringFieldValue>("baz"),
                                       std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 0))));
 
     fixture.applyUpdateToDocument();
@@ -539,19 +539,19 @@ TEST(DocumentUpdateTest, testGenerateSerializedFile)
     const DocumentType *type(repo.getDocumentType("serializetest"));
     DocumentUpdate upd(repo, *type, DocumentId("id:ns:serializetest::update"));
     upd.addUpdate(FieldUpdate(type->getField("intfield"))
-		  .addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(4))));
+		  .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(4))));
     upd.addUpdate(FieldUpdate(type->getField("floatfield"))
-		  .addUpdate(std::make_unique<AssignValueUpdate>(FloatFieldValue(1.00f))));
+		  .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<FloatFieldValue>(1.00f))));
     upd.addUpdate(FieldUpdate(type->getField("arrayoffloatfield"))
-		  .addUpdate(std::make_unique<AddValueUpdate>(FloatFieldValue(5.00f)))
-		  .addUpdate(std::make_unique<AddValueUpdate>(FloatFieldValue(4.23f)))
-		  .addUpdate(std::make_unique<AddValueUpdate>(FloatFieldValue(-1.00f))));
+		  .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<FloatFieldValue>(5.00f)))
+		  .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<FloatFieldValue>(4.23f)))
+		  .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<FloatFieldValue>(-1.00f))));
     upd.addUpdate(FieldUpdate(type->getField("intfield"))
           .addUpdate(std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 3)));
     upd.addUpdate(FieldUpdate(type->getField("wsfield"))
-          .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("foo"),
+          .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<StringFieldValue>("foo"),
                         std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 2)))
-          .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("foo"),
+          .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<StringFieldValue>("foo"),
                         std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Mul, 2))));
     nbostream buf(serializeHEAD(upd));
     writeBufferToFile(buf, "data/serializeupdatecpp.dat");
@@ -569,7 +569,7 @@ TEST(DocumentUpdateTest, testSetBadFieldTypes)
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
     ASSERT_THROW(
         update.addUpdate(FieldUpdate(doc->getField("headerval"))
-                 .addUpdate(std::make_unique<AssignValueUpdate>(FloatFieldValue(4.00f)))),
+                 .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<FloatFieldValue>(4.00f)))),
         std::exception) << "Expected exception when adding a float to an int field.";
 
     update.applyTo(*doc);
@@ -604,7 +604,7 @@ TEST(DocumentUpdateTest, testUpdateApplyNoArrayValues)
     // Assign array field with no array values = empty array
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
     update.addUpdate(FieldUpdate(field)
-                     .addUpdate(std::make_unique<AssignValueUpdate>(ArrayFieldValue(field.getDataType()))));
+                     .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<ArrayFieldValue>(field.getDataType()))));
 
     update.applyTo(*doc);
 
@@ -624,7 +624,7 @@ TEST(DocumentUpdateTest, testUpdateArrayEmptyParamValue)
 
     // Assign array field with no array values = empty array.
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
-    update.addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(ArrayFieldValue(field.getDataType()))));
+    update.addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<ArrayFieldValue>(field.getDataType()))));
     update.applyTo(*doc);
 
     // Verify that the field was set in the document.
@@ -652,7 +652,7 @@ TEST(DocumentUpdateTest, testUpdateWeightedSetEmptyParamValue)
 
     // Assign weighted set with no items = empty set.
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
-    update.addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(WeightedSetFieldValue(field.getDataType()))));
+    update.addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<WeightedSetFieldValue>(field.getDataType()))));
     update.applyTo(*doc);
 
     // Verify that the field was set in the document.
@@ -682,8 +682,8 @@ TEST(DocumentUpdateTest, testUpdateArrayWrongSubtype)
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
     ASSERT_THROW(
         update.addUpdate(FieldUpdate(field)
-                 .addUpdate(std::make_unique<AddValueUpdate>(IntFieldValue(123)))
-                 .addUpdate(std::make_unique<AddValueUpdate>(IntFieldValue(456)))),
+                 .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(123)))
+                 .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(456)))),
         std::exception) << "Expected exception when adding wrong type.";
 
     // Apply update
@@ -732,7 +732,7 @@ TEST(DocumentUpdateTest, testMapValueUpdate)
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field1)
-                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("banana"),
+                   .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<StringFieldValue>("banana"),
                                              std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 1.0))))
         .applyTo(*doc);
     std::unique_ptr<WeightedSetFieldValue> fv1 =
@@ -741,7 +741,7 @@ TEST(DocumentUpdateTest, testMapValueUpdate)
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field2)
-                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("banana"),
+                   .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<StringFieldValue>("banana"),
                                              std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 1.0))))
         .applyTo(*doc);
     auto fv2 = doc->getAs<WeightedSetFieldValue>(field2);
@@ -770,7 +770,7 @@ TEST(DocumentUpdateTest, testMapValueUpdate)
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field1)
-                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("apple"),
+                   .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<StringFieldValue>("apple"),
                                              std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Sub, 1.0))))
         .applyTo(*doc);
 
@@ -780,7 +780,7 @@ TEST(DocumentUpdateTest, testMapValueUpdate)
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field2)
-                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("apple"),
+                   .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<StringFieldValue>("apple"),
                                              std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Sub, 1.0))))
         .applyTo(*doc);
 
@@ -940,10 +940,9 @@ struct TensorUpdateFixture {
 TEST(DocumentUpdateTest, tensor_assign_update_can_be_applied)
 {
     TensorUpdateFixture f;
-    auto newTensor = f.makeBaselineTensor();
-    f.applyUpdate(std::make_unique<AssignValueUpdate>(*newTensor));
+    f.applyUpdate(std::make_unique<AssignValueUpdate>(f.makeBaselineTensor()));
     f.assertDocumentUpdated();
-    f.assertTensor(*newTensor);
+    f.assertTensor(*f.makeBaselineTensor());
 }
 
 TEST(DocumentUpdateTest, tensor_clear_update_can_be_applied)
@@ -1032,7 +1031,7 @@ TEST(DocumentUpdateTest, tensor_modify_update_can_be_applied_to_nonexisting_tens
 TEST(DocumentUpdateTest, tensor_assign_update_can_be_roundtrip_serialized)
 {
     TensorUpdateFixture f;
-    f.assertRoundtripSerialize(AssignValueUpdate(*f.makeBaselineTensor()));
+    f.assertRoundtripSerialize(AssignValueUpdate(f.makeBaselineTensor()));
 }
 
 TEST(DocumentUpdateTest, tensor_add_update_can_be_roundtrip_serialized)
@@ -1162,7 +1161,7 @@ struct TensorUpdateSerializeFixture {
                 (*repo, docType, DocumentId("id:test:test::0"));
 
         result->addUpdate(FieldUpdate(getField("sparse_tensor"))
-                                  .addUpdate(std::make_unique<AssignValueUpdate>(*makeTensor()))
+                                  .addUpdate(std::make_unique<AssignValueUpdate>(makeTensor()))
                                   .addUpdate(std::make_unique<TensorAddUpdate>(makeTensor()))
                                   .addUpdate(std::make_unique<TensorRemoveUpdate>(makeTensor())));
         result->addUpdate(FieldUpdate(getField("dense_tensor"))
@@ -1250,7 +1249,7 @@ CreateIfNonExistentFixture::CreateIfNonExistentFixture()
       update(std::make_unique<DocumentUpdate>(docMan.getTypeRepo(), *document->getDataType(), document->getId()))
 {
     update->addUpdate(FieldUpdate(document->getField("headerval"))
-                              .addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(1))));
+                              .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(1))));
     update->setCreateIfNonExistent(true);
 }
 
@@ -1282,8 +1281,8 @@ ArrayUpdateFixture::ArrayUpdateFixture()
 {
     update = std::make_unique<DocumentUpdate>(doc_man.getTypeRepo(), *doc->getDataType(), doc->getId());
     update->addUpdate(FieldUpdate(array_field)
-                              .addUpdate(std::make_unique<MapValueUpdate>(IntFieldValue(1),
-                                                        std::make_unique<AssignValueUpdate>(StringFieldValue("bar")))));
+                              .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<IntFieldValue>(1),
+                                                        std::make_unique<AssignValueUpdate>(std::make_unique<StringFieldValue>("bar")))));
 }
 ArrayUpdateFixture::~ArrayUpdateFixture() = default;
 
diff --git a/document/src/tests/feed_reject_helper_test.cpp b/document/src/tests/feed_reject_helper_test.cpp
index 6649c9c0208..278e89b15a3 100644
--- a/document/src/tests/feed_reject_helper_test.cpp
+++ b/document/src/tests/feed_reject_helper_test.cpp
@@ -53,22 +53,22 @@ TEST(DocumentRejectTest, requireThatFixedSizeFieldValuesAreDetected) {
 
 TEST(DocumentRejectTest, requireThatClearRemoveTensorRemoveAndArtithmeticUpdatesIgnoreFeedRejection) {
     EXPECT_FALSE(FeedRejectHelper::mustReject(ClearValueUpdate()));
-    EXPECT_FALSE(FeedRejectHelper::mustReject(RemoveValueUpdate(StringFieldValue())));
+    EXPECT_FALSE(FeedRejectHelper::mustReject(RemoveValueUpdate(std::make_unique<StringFieldValue>())));
     EXPECT_FALSE(FeedRejectHelper::mustReject(ArithmeticValueUpdate(ArithmeticValueUpdate::Add, 5.0)));
     EXPECT_FALSE(FeedRejectHelper::mustReject(TensorRemoveUpdate(std::make_unique<TensorFieldValue>())));
 }
 
 TEST(DocumentRejectTest, requireThatAddMapTensorModifyAndTensorAddUpdatesWillBeRejected) {
-    EXPECT_TRUE(FeedRejectHelper::mustReject(AddValueUpdate(IntFieldValue())));
-    EXPECT_TRUE(FeedRejectHelper::mustReject(MapValueUpdate(IntFieldValue(), std::make_unique<ClearValueUpdate>())));
+    EXPECT_TRUE(FeedRejectHelper::mustReject(AddValueUpdate(std::make_unique<IntFieldValue>())));
+    EXPECT_TRUE(FeedRejectHelper::mustReject(MapValueUpdate(std::make_unique<IntFieldValue>(), std::make_unique<ClearValueUpdate>())));
     EXPECT_TRUE(FeedRejectHelper::mustReject(TensorModifyUpdate(TensorModifyUpdate::Operation::REPLACE,
                                                                 std::make_unique<TensorFieldValue>())));
     EXPECT_TRUE(FeedRejectHelper::mustReject(TensorAddUpdate(std::make_unique<TensorFieldValue>())));
 }
 
 TEST(DocumentRejectTest, requireThatAssignUpdatesWillBeRejectedBasedOnTheirContent) {
-    EXPECT_FALSE(FeedRejectHelper::mustReject(AssignValueUpdate(IntFieldValue())));
-    EXPECT_TRUE(FeedRejectHelper::mustReject(AssignValueUpdate(StringFieldValue())));
+    EXPECT_FALSE(FeedRejectHelper::mustReject(AssignValueUpdate(std::make_unique<IntFieldValue>())));
+    EXPECT_TRUE(FeedRejectHelper::mustReject(AssignValueUpdate(std::make_unique<StringFieldValue>())));
 }
 
 }
diff --git a/document/src/tests/testxml.cpp b/document/src/tests/testxml.cpp
index 978ab572214..998d41480f3 100644
--- a/document/src/tests/testxml.cpp
+++ b/document/src/tests/testxml.cpp
@@ -60,16 +60,16 @@ createTestDocumentUpdate(const DocumentTypeRepo& repo)
 
     auto up = std::make_unique<DocumentUpdate>(repo, *type, id);
     up->addUpdate(FieldUpdate(type->getField("intattr"))
-		  .addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(7))));
+		  .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(7))));
     up->addUpdate(FieldUpdate(type->getField("stringattr"))
-		  .addUpdate(std::make_unique<AssignValueUpdate>(StringFieldValue("New value"))));
+		  .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<StringFieldValue>("New value"))));
     up->addUpdate(FieldUpdate(type->getField("arrayattr"))
-		  .addUpdate(std::make_unique<AddValueUpdate>(IntFieldValue(123)))
-		  .addUpdate(std::make_unique<AddValueUpdate>(IntFieldValue(456))));
+		  .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(123)))
+		  .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(456))));
     up->addUpdate(FieldUpdate(type->getField("arrayattr"))
-		  .addUpdate(std::make_unique<RemoveValueUpdate>(IntFieldValue(123)))
-		  .addUpdate(std::make_unique<RemoveValueUpdate>(IntFieldValue(456)))
-		  .addUpdate(std::make_unique<RemoveValueUpdate>(IntFieldValue(789))));
+		  .addUpdate(std::make_unique<RemoveValueUpdate>(std::make_unique<IntFieldValue>(123)))
+		  .addUpdate(std::make_unique<RemoveValueUpdate>(std::make_unique<IntFieldValue>(456)))
+		  .addUpdate(std::make_unique<RemoveValueUpdate>(std::make_unique<IntFieldValue>(789))));
     return up;
 }
 
diff --git a/document/src/vespa/document/base/forcelink.cpp b/document/src/vespa/document/base/forcelink.cpp
index 500b5cf7fa5..cfa3354f5f2 100644
--- a/document/src/vespa/document/base/forcelink.cpp
+++ b/document/src/vespa/document/base/forcelink.cpp
@@ -14,10 +14,10 @@ ForceLink::ForceLink(void)
         DocumentType          type("foo", 1);
         Document              document(type, DocumentId("doc:ns:bar"));
         DocumentUpdate        documentUpdate;
-        MapValueUpdate        mapValueUpdate(IntFieldValue(3), std::make_unique<ClearValueUpdate>());
-        AddValueUpdate        addValueUpdate(IntFieldValue(3));
-        RemoveValueUpdate     removeValueUpdate(IntFieldValue(3));
-        AssignValueUpdate     assignValueUpdate(IntFieldValue(3));
+        MapValueUpdate        mapValueUpdate(std::make_unique<IntFieldValue>(3), std::make_unique<ClearValueUpdate>());
+        AddValueUpdate        addValueUpdate(std::make_unique<IntFieldValue>(3));
+        RemoveValueUpdate     removeValueUpdate(std::make_unique<IntFieldValue>(3));
+        AssignValueUpdate     assignValueUpdate(std::make_unique<IntFieldValue>(3));
         ClearValueUpdate      clearValueUpdate;
         ArithmeticValueUpdate arithmeticValueUpdate(ArithmeticValueUpdate::Add, 3);
     }
diff --git a/document/src/vespa/document/update/addvalueupdate.cpp b/document/src/vespa/document/update/addvalueupdate.cpp
index 3b593d3e9b2..102f8ceebbe 100644
--- a/document/src/vespa/document/update/addvalueupdate.cpp
+++ b/document/src/vespa/document/update/addvalueupdate.cpp
@@ -18,9 +18,9 @@ using namespace vespalib::xml;
 namespace document {
 
 
-AddValueUpdate:: AddValueUpdate(const FieldValue& value, int weight)
+AddValueUpdate:: AddValueUpdate(std::unique_ptr<FieldValue> value, int weight)
     : ValueUpdate(Add),
-      _value(value.clone()),
+      _value(std::move(value)),
       _weight(weight)
 {}
 
diff --git a/document/src/vespa/document/update/addvalueupdate.h b/document/src/vespa/document/update/addvalueupdate.h
index 2ab7a98e842..f891c368f96 100644
--- a/document/src/vespa/document/update/addvalueupdate.h
+++ b/document/src/vespa/document/update/addvalueupdate.h
@@ -13,24 +13,24 @@
 namespace document {
 
 class AddValueUpdate final : public ValueUpdate {
-    FieldValue::CP _value; // The field value to add by this update.
+    std::unique_ptr<FieldValue> _value; // The field value to add by this update.
     int _weight; // The weight to assign to the contained value.
 
     // Used by ValueUpdate's static factory function
     // Private because it generates an invalid object.
     friend class ValueUpdate;
-    AddValueUpdate() : ValueUpdate(Add), _value(0), _weight(1) {}
+    AddValueUpdate() : ValueUpdate(Add), _value(), _weight(1) {}
     ACCEPT_UPDATE_VISITOR;
 public:
-    typedef std::unique_ptr<AddValueUpdate> UP;
-
     /**
      * The default constructor requires initial values for all member variables.
      *
      * @param value The field value to add.
      * @param weight The weight for the field value.
      */
-    AddValueUpdate(const FieldValue& value, int weight = 1);
+    AddValueUpdate(std::unique_ptr<FieldValue> value, int weight = 1);
+    AddValueUpdate(const AddValueUpdate &) = delete;
+    AddValueUpdate & operator =(const AddValueUpdate &) = delete;
     ~AddValueUpdate();
 
     bool operator==(const ValueUpdate& other) const override;
@@ -42,17 +42,6 @@ public:
     int getWeight() const { return _weight; }
 
     /**
-     * Sets the field value to add during this update.
-     *
-     * @param value The new field value.
-     * @return A reference to this object so you can chain calls.
-     */
-    AddValueUpdate& setValue(const FieldValue& value) {
-        _value.reset(value.clone());
-        return *this;
-    }
-
-    /**
      * Sets the weight to assign to the value of this.
      *
      * @return A reference to this object so you can chain calls.
diff --git a/document/src/vespa/document/update/arithmeticvalueupdate.h b/document/src/vespa/document/update/arithmeticvalueupdate.h
index c82a5b4c338..7651c838458 100644
--- a/document/src/vespa/document/update/arithmeticvalueupdate.h
+++ b/document/src/vespa/document/update/arithmeticvalueupdate.h
@@ -25,7 +25,7 @@ public:
 
 private:
     Operator _operator; // The operator of the arithmetic operation.
-    double _operand; // The operand of the arithmetic operation.
+    double   _operand; // The operand of the arithmetic operation.
 
     // Used by ValueUpdate's static factory function
     // Private because it generates an invalid object.
@@ -50,12 +50,8 @@ public:
           _operator(opt),
           _operand(opn) {}
 
-    ArithmeticValueUpdate(const ArithmeticValueUpdate& update)
-        : ValueUpdate(update),
-          _operator(update._operator),
-          _operand(update._operand) {}
-
-    ArithmeticValueUpdate &operator=(const ArithmeticValueUpdate &rhs) = default;
+    ArithmeticValueUpdate(const ArithmeticValueUpdate& update) = delete;
+    ArithmeticValueUpdate &operator=(const ArithmeticValueUpdate &rhs) = delete;
 
     bool operator==(const ValueUpdate& other) const override;
 
diff --git a/document/src/vespa/document/update/assignvalueupdate.cpp b/document/src/vespa/document/update/assignvalueupdate.cpp
index 363eff92bf0..32bded8cfd7 100644
--- a/document/src/vespa/document/update/assignvalueupdate.cpp
+++ b/document/src/vespa/document/update/assignvalueupdate.cpp
@@ -21,9 +21,9 @@ AssignValueUpdate::AssignValueUpdate()
       _value()
 {}
 
-AssignValueUpdate::AssignValueUpdate(const FieldValue& value)
+AssignValueUpdate::AssignValueUpdate(std::unique_ptr<FieldValue> value)
     : ValueUpdate(Assign),
-      _value(value.clone())
+      _value(std::move(value))
 {
 }
 AssignValueUpdate::~AssignValueUpdate() = default;
@@ -36,7 +36,11 @@ AssignValueUpdate::operator==(const ValueUpdate& other) const
 {
     if (other.getType() != Assign) return false;
     const AssignValueUpdate& o(static_cast<const AssignValueUpdate&>(other));
-    return _value == o._value;
+    if (_value && o._value) {
+        return *_value == *o._value;
+    } else {
+        return bool(_value) == bool(o._value);
+    }
 }
 
 // Ensure that this update is compatible with given field.
diff --git a/document/src/vespa/document/update/assignvalueupdate.h b/document/src/vespa/document/update/assignvalueupdate.h
index 9df2084ef97..1e006d3baed 100644
--- a/document/src/vespa/document/update/assignvalueupdate.h
+++ b/document/src/vespa/document/update/assignvalueupdate.h
@@ -17,13 +17,14 @@
 namespace document {
 
 class AssignValueUpdate final : public ValueUpdate {
-    FieldValue::CP _value;
+    std::unique_ptr<FieldValue> _value;
 
     ACCEPT_UPDATE_VISITOR;
 public:
-    typedef std::unique_ptr<AssignValueUpdate> UP;
     AssignValueUpdate();
-    AssignValueUpdate(const FieldValue& value);
+    AssignValueUpdate(std::unique_ptr<FieldValue> value);
+    AssignValueUpdate(const AssignValueUpdate& value) = delete;
+    AssignValueUpdate & operator=(const AssignValueUpdate& value) = delete;
     ~AssignValueUpdate() override;
 
     bool operator==(const ValueUpdate& other) const override;
diff --git a/document/src/vespa/document/update/clearvalueupdate.h b/document/src/vespa/document/update/clearvalueupdate.h
index 2a68814f8b0..770f0a91d07 100644
--- a/document/src/vespa/document/update/clearvalueupdate.h
+++ b/document/src/vespa/document/update/clearvalueupdate.h
@@ -14,10 +14,9 @@ namespace document {
 class ClearValueUpdate final : public ValueUpdate {
     ACCEPT_UPDATE_VISITOR;
 public:
-    typedef std::unique_ptr<ClearValueUpdate> UP;
-    ClearValueUpdate(const ClearValueUpdate& update) = default;
+    ClearValueUpdate(const ClearValueUpdate& update) = delete;
+    ClearValueUpdate &operator=(const ClearValueUpdate &rhs) = delete;
     ClearValueUpdate() : ValueUpdate(Clear) {}
-    ClearValueUpdate &operator=(const ClearValueUpdate &rhs) = default;
     bool operator==(const ValueUpdate& other) const override;
 
     void checkCompatibility(const Field& field) const override;
diff --git a/document/src/vespa/document/update/mapvalueupdate.cpp b/document/src/vespa/document/update/mapvalueupdate.cpp
index 93f2029b92f..47346133e17 100644
--- a/document/src/vespa/document/update/mapvalueupdate.cpp
+++ b/document/src/vespa/document/update/mapvalueupdate.cpp
@@ -16,24 +16,12 @@ using namespace vespalib::xml;
 
 namespace document {
 
-MapValueUpdate::MapValueUpdate(const FieldValue& key, std::unique_ptr<ValueUpdate> update)
+MapValueUpdate::MapValueUpdate(std::unique_ptr<FieldValue> key, std::unique_ptr<ValueUpdate> update)
     : ValueUpdate(Map),
-      _key(key.clone()),
+      _key(std::move(key)),
       _update(std::move(update))
 {}
 
-MapValueUpdate::MapValueUpdate(const MapValueUpdate &)
-    : ValueUpdate(Map),
-      _key(),
-      _update()
-{
-    abort(); // TODO Will never be called, remove
-}
-MapValueUpdate &
-MapValueUpdate::operator = (const MapValueUpdate &) {
-    abort(); // TODO Will never be called, remove
-    return *this;
-}
 MapValueUpdate::~MapValueUpdate() = default;
 
 bool
diff --git a/document/src/vespa/document/update/mapvalueupdate.h b/document/src/vespa/document/update/mapvalueupdate.h
index 93d6c844899..dfbb880f422 100644
--- a/document/src/vespa/document/update/mapvalueupdate.h
+++ b/document/src/vespa/document/update/mapvalueupdate.h
@@ -26,9 +26,9 @@ public:
      * @param key The identifier of the field value to be updated.
      * @param update The update to map to apply to the field value of this.
      */
-    MapValueUpdate(const FieldValue& key, std::unique_ptr<ValueUpdate> update);
-    MapValueUpdate(const MapValueUpdate &);
-    MapValueUpdate & operator = (const MapValueUpdate &);
+    MapValueUpdate(std::unique_ptr<FieldValue> key, std::unique_ptr<ValueUpdate> update);
+    MapValueUpdate(const MapValueUpdate &) = delete;
+    MapValueUpdate & operator = (const MapValueUpdate &) = delete;
     MapValueUpdate(MapValueUpdate &&) = default;
     MapValueUpdate & operator = (MapValueUpdate &&) = default;
 
diff --git a/document/src/vespa/document/update/removevalueupdate.cpp b/document/src/vespa/document/update/removevalueupdate.cpp
index 4789df8d7ab..3c381148e94 100644
--- a/document/src/vespa/document/update/removevalueupdate.cpp
+++ b/document/src/vespa/document/update/removevalueupdate.cpp
@@ -16,9 +16,9 @@ using namespace vespalib::xml;
 
 namespace document {
 
-RemoveValueUpdate::RemoveValueUpdate(const FieldValue& key)
+RemoveValueUpdate::RemoveValueUpdate(std::unique_ptr<FieldValue> key)
     : ValueUpdate(Remove),
-      _key(key.clone())
+      _key(std::move(key))
 {}
 
 RemoveValueUpdate::~RemoveValueUpdate() = default;
diff --git a/document/src/vespa/document/update/removevalueupdate.h b/document/src/vespa/document/update/removevalueupdate.h
index 0c57817ce33..cfce9b5234a 100644
--- a/document/src/vespa/document/update/removevalueupdate.h
+++ b/document/src/vespa/document/update/removevalueupdate.h
@@ -11,21 +11,21 @@
 namespace document {
 
 class RemoveValueUpdate final : public ValueUpdate {
-    FieldValue::CP _key; // The field value to remove by this update.
+    std::unique_ptr<FieldValue> _key; // The field value to remove by this update.
 
     ACCEPT_UPDATE_VISITOR;
     friend ValueUpdate;
     RemoveValueUpdate() : ValueUpdate(Remove), _key() {}
 public:
-    typedef std::unique_ptr<RemoveValueUpdate> UP;
-
     /**
      * The default constructor requires initial values for all member variables.
      *
      * @param value The identifier of the field value to update.
      */
-    RemoveValueUpdate(const FieldValue& key);
-    ~RemoveValueUpdate();
+    RemoveValueUpdate(std::unique_ptr<FieldValue> key);
+    RemoveValueUpdate(const RemoveValueUpdate &) = delete;
+    RemoveValueUpdate & operator=(const RemoveValueUpdate &) = delete;
+    ~RemoveValueUpdate() override;
 
     bool operator==(const ValueUpdate& other) const override;
 
diff --git a/document/src/vespa/document/update/tensor_add_update.cpp b/document/src/vespa/document/update/tensor_add_update.cpp
index 49c73722147..b3bb4d7623d 100644
--- a/document/src/vespa/document/update/tensor_add_update.cpp
+++ b/document/src/vespa/document/update/tensor_add_update.cpp
@@ -29,13 +29,6 @@ TensorAddUpdate::TensorAddUpdate()
 {
 }
 
-TensorAddUpdate::TensorAddUpdate(const TensorAddUpdate &rhs)
-    : ValueUpdate(rhs),
-      TensorUpdate(rhs),
-      _tensor(rhs._tensor->clone())
-{
-}
-
 TensorAddUpdate::TensorAddUpdate(std::unique_ptr<TensorFieldValue> &&tensor)
     : ValueUpdate(TensorAdd),
       TensorUpdate(),
@@ -45,20 +38,6 @@ TensorAddUpdate::TensorAddUpdate(std::unique_ptr<TensorFieldValue> &&tensor)
 
 TensorAddUpdate::~TensorAddUpdate() = default;
 
-TensorAddUpdate &
-TensorAddUpdate::operator=(const TensorAddUpdate &rhs)
-{
-    _tensor.reset(rhs._tensor->clone());
-    return *this;
-}
-
-TensorAddUpdate &
-TensorAddUpdate::operator=(TensorAddUpdate &&rhs)
-{
-    _tensor = std::move(rhs._tensor);
-    return *this;
-}
-
 bool
 TensorAddUpdate::operator==(const ValueUpdate &other) const
 {
diff --git a/document/src/vespa/document/update/tensor_add_update.h b/document/src/vespa/document/update/tensor_add_update.h
index 7e62f2db71a..00346b4e723 100644
--- a/document/src/vespa/document/update/tensor_add_update.h
+++ b/document/src/vespa/document/update/tensor_add_update.h
@@ -19,13 +19,12 @@ class TensorAddUpdate final : public ValueUpdate, public TensorUpdate {
 
     friend ValueUpdate;
     TensorAddUpdate();
-    TensorAddUpdate(const TensorAddUpdate &rhs);
     ACCEPT_UPDATE_VISITOR;
 public:
     TensorAddUpdate(std::unique_ptr<TensorFieldValue> &&tensor);
+    TensorAddUpdate(const TensorAddUpdate &rhs) = delete;
+    TensorAddUpdate &operator=(const TensorAddUpdate &rhs) = delete;
     ~TensorAddUpdate() override;
-    TensorAddUpdate &operator=(const TensorAddUpdate &rhs);
-    TensorAddUpdate &operator=(TensorAddUpdate &&rhs);
     bool operator==(const ValueUpdate &other) const override;
     const TensorFieldValue &getTensor() const { return *_tensor; }
     void checkCompatibility(const Field &field) const override;
diff --git a/document/src/vespa/document/update/tensor_modify_update.cpp b/document/src/vespa/document/update/tensor_modify_update.cpp
index 6abed60af17..92b2a8672c3 100644
--- a/document/src/vespa/document/update/tensor_modify_update.cpp
+++ b/document/src/vespa/document/update/tensor_modify_update.cpp
@@ -91,16 +91,6 @@ TensorModifyUpdate::TensorModifyUpdate()
 {
 }
 
-TensorModifyUpdate::TensorModifyUpdate(const TensorModifyUpdate &rhs)
-    : ValueUpdate(rhs),
-      TensorUpdate(),
-      _operation(rhs._operation),
-      _tensorType(std::make_unique<TensorDataType>(*rhs._tensorType)),
-      _tensor(static_cast<TensorFieldValue *>(_tensorType->createFieldValue().release()))
-{
-    *_tensor = *rhs._tensor;
-}
-
 TensorModifyUpdate::TensorModifyUpdate(Operation operation, std::unique_ptr<TensorFieldValue> tensor)
     : ValueUpdate(TensorModify),
       TensorUpdate(),
@@ -113,28 +103,6 @@ TensorModifyUpdate::TensorModifyUpdate(Operation operation, std::unique_ptr<Tens
 
 TensorModifyUpdate::~TensorModifyUpdate() = default;
 
-TensorModifyUpdate &
-TensorModifyUpdate::operator=(const TensorModifyUpdate &rhs)
-{
-    if (&rhs != this) {
-        _operation = rhs._operation;
-        _tensor.reset();
-        _tensorType = std::make_unique<TensorDataType>(*rhs._tensorType);
-        _tensor.reset(dynamic_cast<TensorFieldValue *>(_tensorType->createFieldValue().release()));
-        *_tensor = *rhs._tensor;
-    }
-    return *this;
-}
-
-TensorModifyUpdate &
-TensorModifyUpdate::operator=(TensorModifyUpdate &&rhs)
-{
-    _operation = rhs._operation;
-    _tensorType = std::move(rhs._tensorType);
-    _tensor = std::move(rhs._tensor);
-    return *this;
-}
-
 bool
 TensorModifyUpdate::operator==(const ValueUpdate &other) const
 {
diff --git a/document/src/vespa/document/update/tensor_modify_update.h b/document/src/vespa/document/update/tensor_modify_update.h
index 9fb69ec5a13..9386b4f8a1b 100644
--- a/document/src/vespa/document/update/tensor_modify_update.h
+++ b/document/src/vespa/document/update/tensor_modify_update.h
@@ -32,13 +32,13 @@ private:
 
     friend ValueUpdate;
     TensorModifyUpdate();
-    TensorModifyUpdate(const TensorModifyUpdate &rhs);
     ACCEPT_UPDATE_VISITOR;
 public:
     TensorModifyUpdate(Operation operation, std::unique_ptr<TensorFieldValue> tensor);
+    TensorModifyUpdate(const TensorModifyUpdate &rhs) = delete;
+    TensorModifyUpdate &operator=(const TensorModifyUpdate &rhs) = delete;
     ~TensorModifyUpdate() override;
-    TensorModifyUpdate &operator=(const TensorModifyUpdate &rhs);
-    TensorModifyUpdate &operator=(TensorModifyUpdate &&rhs);
+
     bool operator==(const ValueUpdate &other) const override;
     Operation getOperation() const { return _operation; }
     const TensorFieldValue &getTensor() const { return *_tensor; }
diff --git a/document/src/vespa/document/update/tensor_remove_update.cpp b/document/src/vespa/document/update/tensor_remove_update.cpp
index 4bfb6bc6b18..74c0cbe6c63 100644
--- a/document/src/vespa/document/update/tensor_remove_update.cpp
+++ b/document/src/vespa/document/update/tensor_remove_update.cpp
@@ -46,14 +46,6 @@ TensorRemoveUpdate::TensorRemoveUpdate()
 {
 }
 
-TensorRemoveUpdate::TensorRemoveUpdate(const TensorRemoveUpdate &rhs)
-    : ValueUpdate(rhs),
-      TensorUpdate(rhs),
-      _tensorType(std::make_unique<TensorDataType>(*rhs._tensorType)),
-      _tensor(rhs._tensor->clone())
-{
-}
-
 TensorRemoveUpdate::TensorRemoveUpdate(std::unique_ptr<TensorFieldValue> tensor)
     : ValueUpdate(TensorRemove),
       TensorUpdate(),
@@ -65,26 +57,6 @@ TensorRemoveUpdate::TensorRemoveUpdate(std::unique_ptr<TensorFieldValue> tensor)
 
 TensorRemoveUpdate::~TensorRemoveUpdate() = default;
 
-TensorRemoveUpdate &
-TensorRemoveUpdate::operator=(const TensorRemoveUpdate &rhs)
-{
-    if (&rhs != this) {
-        _tensor.reset();
-        _tensorType = std::make_unique<TensorDataType>(*rhs._tensorType);
-        _tensor.reset(static_cast<TensorFieldValue *>(_tensorType->createFieldValue().release()));
-        *_tensor = *rhs._tensor;
-    }
-    return *this;
-}
-
-TensorRemoveUpdate &
-TensorRemoveUpdate::operator=(TensorRemoveUpdate &&rhs)
-{
-    _tensorType = std::move(rhs._tensorType);
-    _tensor = std::move(rhs._tensor);
-    return *this;
-}
-
 bool
 TensorRemoveUpdate::operator==(const ValueUpdate &other) const
 {
diff --git a/document/src/vespa/document/update/tensor_remove_update.h b/document/src/vespa/document/update/tensor_remove_update.h
index 00c886fa41f..06b0c512b4b 100644
--- a/document/src/vespa/document/update/tensor_remove_update.h
+++ b/document/src/vespa/document/update/tensor_remove_update.h
@@ -23,14 +23,13 @@ private:
 
     friend ValueUpdate;
     TensorRemoveUpdate();
-    TensorRemoveUpdate(const TensorRemoveUpdate &rhs);
     ACCEPT_UPDATE_VISITOR;
 
 public:
     TensorRemoveUpdate(std::unique_ptr<TensorFieldValue> tensor);
+    TensorRemoveUpdate(const TensorRemoveUpdate &rhs) = delete;
+    TensorRemoveUpdate &operator=(const TensorRemoveUpdate &rhs) = delete;
     ~TensorRemoveUpdate() override;
-    TensorRemoveUpdate &operator=(const TensorRemoveUpdate &rhs);
-    TensorRemoveUpdate &operator=(TensorRemoveUpdate &&rhs);
     const TensorFieldValue &getTensor() const { return *_tensor; }
     std::unique_ptr<vespalib::eval::Value> applyTo(const vespalib::eval::Value &tensor) const;
     std::unique_ptr<Value> apply_to(const Value &tensor,