GC unused timestamp in schema.

3 files changed, 25 insertions, 133 deletions

diff --git a/searchcommon/src/tests/schema/schema_test.cpp b/searchcommon/src/tests/schema/schema_test.cpp
index 3d35b11a51a..ff4c22bad84 100644
--- a/searchcommon/src/tests/schema/schema_test.cpp
+++ b/searchcommon/src/tests/schema/schema_test.cpp
@@ -243,55 +243,16 @@ TEST(SchemaTest, test_load_and_save)
     }
 }
 
-TEST(SchemaTest, require_that_schema_can_save_and_load_timestamps_for_fields)
-{
-    const fastos::TimeStamp timestamp(42);
-    const std::string file_name = "schema-with-timestamps.txt";
-    Schema s;
-    Schema::IndexField f("foo", DataType::STRING);
-    f.setTimestamp(timestamp);
-    s.addIndexField(f);
-    ASSERT_TRUE(s.saveToFile(file_name));
-    Schema s2;
-    ASSERT_TRUE(s2.loadFromFile(file_name));
-    ASSERT_EQ(1u, s2.getNumIndexFields());
-    EXPECT_EQ(timestamp, s2.getIndexField(0).getTimestamp());
-}
-
-TEST(SchemaTest, require_that_timestamps_are_omitted_when_0)
-{
-    const std::string file_name = "schema-without-timestamps.txt";
-    Schema s;
-    s.addIndexField(Schema::IndexField("foo", DataType::STRING));
-    ASSERT_TRUE(s.saveToFile(file_name));
-
-    std::ifstream file(file_name.c_str());
-    ASSERT_TRUE(file.good());
-    while (file) {
-        std::string line;
-        getline(file, line);
-        EXPECT_NE("indexfield[0].timestamp 0", line);
-    }
-
-    Schema s2;
-    ASSERT_TRUE(s2.loadFromFile(file_name));
-    ASSERT_EQ(1u, s2.getNumIndexFields());
-}
-
 void
-addAllFieldTypes(const string& name, Schema& schema,
-                 fastos::TimeStamp timestamp)
+addAllFieldTypes(const string& name, Schema& schema)
 {
     Schema::IndexField index_field(name, DataType::STRING);
-    index_field.setTimestamp(timestamp);
     schema.addIndexField(index_field);
 
     Schema::AttributeField attribute_field(name, DataType::STRING);
-    attribute_field.setTimestamp(timestamp);
     schema.addAttributeField(attribute_field);
 
     Schema::SummaryField summary_field(name, DataType::STRING);
-    summary_field.setTimestamp(timestamp);
     schema.addSummaryField(summary_field);
 
     schema.addFieldSet(Schema::FieldSet(name));
@@ -301,12 +262,10 @@ TEST(SchemaTest, require_that_schemas_can_be_added)
 {
     const string name1 = "foo";
     const string name2 = "bar";
-    const fastos::TimeStamp timestamp1(42);
-    const fastos::TimeStamp timestamp2(84);
     Schema s1;
-    addAllFieldTypes(name1, s1, timestamp1);
+    addAllFieldTypes(name1, s1);
     Schema s2;
-    addAllFieldTypes(name2, s2, timestamp2);
+    addAllFieldTypes(name2, s2);
 
     Schema::UP sum = Schema::make_union(s1, s2);
     ASSERT_EQ(2u, sum->getNumIndexFields());
@@ -334,7 +293,7 @@ TEST(SchemaTest, require_that_schemas_can_be_added)
 TEST(SchemaTest, require_that_S_union_S_equals_S_for_schema_S)
 {
     Schema schema;
-    addAllFieldTypes("foo", schema, 42);
+    addAllFieldTypes("foo", schema);
 
     Schema::UP sum = Schema::make_union(schema, schema);
     EXPECT_TRUE(schema == *sum);
@@ -344,56 +303,35 @@ TEST(SchemaTest, require_that_schema_can_calculate_set_difference)
 {
     const string name1 = "foo";
     const string name2 = "bar";
-    const fastos::TimeStamp timestamp1(42);
-    const fastos::TimeStamp timestamp2(84);
     Schema s1;
-    addAllFieldTypes(name1, s1, timestamp1);
-    addAllFieldTypes(name2, s1, timestamp2);
+    addAllFieldTypes(name1, s1);
+    addAllFieldTypes(name2, s1);
     Schema s2;
-    addAllFieldTypes(name2, s2, timestamp2);
+    addAllFieldTypes(name2, s2);
 
     Schema::UP schema = Schema::set_difference(s1, s2);
 
     Schema expected;
-    addAllFieldTypes(name1, expected, timestamp1);
+    addAllFieldTypes(name1, expected);
     EXPECT_TRUE(expected == *schema);
 }
 
-TEST(SchemaTest, require_that_get_old_fields_returns_a_subset_of_a_schema)
-{
-    Schema schema;
-    const int64_t limit_timestamp = 1000;
-
-    addAllFieldTypes("bar", schema, fastos::TimeStamp(limit_timestamp - 1));
-    addAllFieldTypes("foo", schema, fastos::TimeStamp(limit_timestamp + 1));
-
-    Schema::UP old_fields =
-        schema.getOldFields(fastos::TimeStamp(limit_timestamp));
-
-    EXPECT_EQ(1u, old_fields->getNumIndexFields());
-    EXPECT_EQ("bar", old_fields->getIndexField(0).getName());
-    EXPECT_EQ(1u, old_fields->getNumAttributeFields());
-    EXPECT_EQ(1u, old_fields->getNumSummaryFields());
-}
-
 TEST(SchemaTest, require_that_schema_can_calculate_intersection)
 {
     const string name1 = "foo";
     const string name2 = "bar";
     const string name3 = "baz";
-    const fastos::TimeStamp timestamp1(42);
-    const fastos::TimeStamp timestamp2(84);
     Schema s1;
-    addAllFieldTypes(name1, s1, timestamp1);
-    addAllFieldTypes(name2, s1, timestamp2);
+    addAllFieldTypes(name1, s1);
+    addAllFieldTypes(name2, s1);
     Schema s2;
-    addAllFieldTypes(name2, s2, timestamp2);
-    addAllFieldTypes(name3, s2, timestamp2);
+    addAllFieldTypes(name2, s2);
+    addAllFieldTypes(name3, s2);
 
     Schema::UP schema = Schema::intersect(s1, s2);
 
     Schema expected;
-    addAllFieldTypes(name2, expected, timestamp2);
+    addAllFieldTypes(name2, expected);
     EXPECT_TRUE(expected == *schema);
 }
 
diff --git a/searchcommon/src/vespa/searchcommon/common/schema.cpp b/searchcommon/src/vespa/searchcommon/common/schema.cpp
index afc023a68d7..fb0ea74d3e9 100644
--- a/searchcommon/src/vespa/searchcommon/common/schema.cpp
+++ b/searchcommon/src/vespa/searchcommon/common/schema.cpp
@@ -72,33 +72,26 @@ const uint32_t Schema::UNKNOWN_FIELD_ID(std::numeric_limits<uint32_t>::max());
 Schema::Field::Field(vespalib::stringref n, DataType dt)
     : _name(n),
       _dataType(dt),
-      _collectionType(schema::CollectionType::SINGLE),
-      _timestamp(0)
+      _collectionType(schema::CollectionType::SINGLE)
 {
 }
 
-Schema::Field::Field(vespalib::stringref n,
-                     DataType dt, CollectionType ct)
+Schema::Field::Field(vespalib::stringref n, DataType dt, CollectionType ct)
     : _name(n),
       _dataType(dt),
-      _collectionType(ct),
-      _timestamp(0)
+      _collectionType(ct)
 {
 }
 
 // XXX: Resource leak if exception is thrown.
 Schema::Field::Field(const std::vector<vespalib::string> & lines)
     : _name(ConfigParser::parse<vespalib::string>("name", lines)),
-      _dataType(schema::dataTypeFromName(ConfigParser::parse<vespalib::string>(
-                              "datatype", lines))),
-      _collectionType(
-              schema::collectionTypeFromName(ConfigParser::parse<vespalib::string>(
-                              "collectiontype", lines))),
-      _timestamp(ConfigParser::parse<int64_t>("timestamp", lines, 0))
+      _dataType(schema::dataTypeFromName(ConfigParser::parse<vespalib::string>("datatype", lines))),
+      _collectionType(schema::collectionTypeFromName(ConfigParser::parse<vespalib::string>("collectiontype", lines)))
 {
 }
 
-Schema::Field::~Field() { }
+Schema::Field::~Field() = default;
 
 void
 Schema::Field::write(vespalib::asciistream & os, vespalib::stringref prefix) const
@@ -106,27 +99,22 @@ Schema::Field::write(vespalib::asciistream & os, vespalib::stringref prefix) con
     os << prefix << "name " << _name << "\n";
     os << prefix << "datatype " << getTypeName(_dataType) << "\n";
     os << prefix << "collectiontype " << getTypeName(_collectionType) << "\n";
-    if (_timestamp) {
-        os << prefix << "timestamp " << _timestamp.val() << "\n";
-    }
 }
 
 bool
 Schema::Field::operator==(const Field &rhs) const
 {
     return _name == rhs._name &&
-       _dataType == rhs._dataType &&
- _collectionType == rhs._collectionType &&
-      _timestamp == rhs._timestamp;
+           _dataType == rhs._dataType &&
+           _collectionType == rhs._collectionType;
 }
 
 bool
 Schema::Field::operator!=(const Field &rhs) const
 {
     return _name != rhs._name ||
-       _dataType != rhs._dataType ||
- _collectionType != rhs._collectionType ||
-      _timestamp != rhs._timestamp;
+           _dataType != rhs._dataType ||
+           _collectionType != rhs._collectionType;
 }
 
 Schema::IndexField::IndexField(vespalib::stringref name, DataType dt)
@@ -488,8 +476,7 @@ struct IntersectHelper {
 };
 
 template <>
-bool IntersectHelper::is_matching(const Schema::FieldSet &f1,
-                                  const Schema::FieldSet &f2) {
+bool IntersectHelper::is_matching(const Schema::FieldSet &f1, const Schema::FieldSet &f2) {
     if (f1.getFields() != f2.getFields())
         return false;
     const std::vector<vespalib::string> fields = f1.getFields();
@@ -503,21 +490,7 @@ bool IntersectHelper::is_matching(const Schema::FieldSet &f1,
 }
 
 template <typename T, typename Map>
-void addOldEntries(const std::vector<T> &entries,
-                   fastos::TimeStamp limit_timestamp,
-                   std::vector<T> &v, Map &name2id_map) {
-    for (typename std::vector<T>::const_iterator
-             it = entries.begin(); it != entries.end(); ++it) {
-        if (it->getTimestamp() < limit_timestamp) {
-            name2id_map[it->getName()] = v.size();
-            v.push_back(*it);
-        }
-    }
-}
-
-template <typename T, typename Map>
-void addEntries(const std::vector<T> &entries, std::vector<T> &v,
-                Map &name2id_map) {
+void addEntries(const std::vector<T> &entries, std::vector<T> &v, Map &name2id_map) {
     for (typename std::vector<T>::const_iterator
              it = entries.begin(); it != entries.end(); ++it) {
         if (name2id_map.find(it->getName()) == name2id_map.end()) {
@@ -541,19 +514,6 @@ void difference(const std::vector<T> &minuend, const Map &subtrahend_map,
 }  // namespace
 
 Schema::UP
-Schema::getOldFields(fastos::TimeStamp limit_timestamp)
-{
-    Schema::UP schema(new Schema);
-    addOldEntries(_indexFields, limit_timestamp,
-                  schema->_indexFields, schema->_indexIds);
-    addOldEntries(_attributeFields, limit_timestamp,
-                  schema->_attributeFields, schema->_attributeIds);
-    addOldEntries(_summaryFields, limit_timestamp,
-                  schema->_summaryFields, schema->_summaryIds);
-    return schema;
-}
-
-Schema::UP
 Schema::intersect(const Schema &lhs, const Schema &rhs)
 {
     IntersectHelper h;
diff --git a/searchcommon/src/vespa/searchcommon/common/schema.h b/searchcommon/src/vespa/searchcommon/common/schema.h
index 0b675710e8b..7561bf8b741 100644
--- a/searchcommon/src/vespa/searchcommon/common/schema.h
+++ b/searchcommon/src/vespa/searchcommon/common/schema.h
@@ -36,7 +36,6 @@ public:
         vespalib::string  _name;
         DataType          _dataType;
         CollectionType    _collectionType;
-        fastos::TimeStamp _timestamp;
 
     public:
         Field(vespalib::stringref n, DataType dt);
@@ -49,8 +48,6 @@ public:
 
         virtual ~Field();
 
-        void setTimestamp(fastos::TimeStamp ts) { _timestamp = ts; }
-
         virtual void
         write(vespalib::asciistream & os,
               vespalib::stringref prefix) const;
@@ -58,7 +55,6 @@ public:
         const vespalib::string &getName() const { return _name; }
         DataType getDataType() const { return _dataType; }
         CollectionType getCollectionType() const { return _collectionType; }
-        fastos::TimeStamp getTimestamp() const { return _timestamp; }
 
         bool matchingTypes(const Field &rhs) const {
             return getDataType() == rhs.getDataType() &&
@@ -389,8 +385,6 @@ public:
     void swap(Schema &rhs);
     void clear();
 
-    Schema::UP getOldFields(fastos::TimeStamp limit_timestamp);
-
     static Schema::UP intersect(const Schema &lhs, const Schema &rhs);
     static Schema::UP make_union(const Schema &lhs, const Schema &rhs);
     static Schema::UP set_difference(const Schema &lhs, const Schema &rhs);