path: root/searchlib/src/vespa/searchcommon/common/schema.h

// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.

#pragma once

#include "datatype.h"
#include <vespa/config/common/types.h>
#include <vespa/vespalib/stllike/hash_map.h>

namespace vespalib { class asciistream; }
namespace search::index {

/**
 * Schema class used to give a high-level description of the content
 * of an index.
 **/
class Schema
{
public:
    using UP = std::unique_ptr<Schema>;
    using SP = std::shared_ptr<Schema>;

    using DataType = schema::DataType;
    using CollectionType = schema::CollectionType;

    /**
     * A single field has a name, data type and collection
     * type. Various aspects (index/attribute) may have
     * limitations on what types are supported in the back-end.
     **/
    class Field
    {
        vespalib::string  _name;
        DataType          _dataType;
        CollectionType    _collectionType;
        vespalib::string  _tensor_spec;

    public:
        Field(vespalib::stringref n, DataType dt) noexcept;
        Field(vespalib::stringref n, DataType dt, CollectionType ct) noexcept;
        Field(vespalib::stringref n, DataType dt, CollectionType ct, vespalib::stringref tensor_spec) noexcept;

        /**
         * Create this field based on the given config lines.
         **/
        Field(const config::StringVector & lines);
        Field(const Field &) noexcept;
        Field & operator = (const Field &) noexcept;
        Field(Field &&) noexcept;
        Field & operator = (Field &&) noexcept;

        virtual ~Field();

        virtual void write(vespalib::asciistream & os, vespalib::stringref prefix) const;

        const vespalib::string &getName() const noexcept { return _name; }
        DataType getDataType() const noexcept { return _dataType; }
        CollectionType getCollectionType() const noexcept { return _collectionType; }
        const vespalib::string& get_tensor_spec() const noexcept { return _tensor_spec; }

        bool matchingTypes(const Field &rhs) const noexcept {
            return getDataType() == rhs.getDataType() &&
             getCollectionType() == rhs.getCollectionType();
        }

        bool operator==(const Field &rhs) const noexcept;
        bool operator!=(const Field &rhs) const noexcept;
    };


    /**
     * A representation of an index field with extra information on
     * how the index should be generated.
     **/
    class IndexField : public Field {
    private:
        uint32_t _avgElemLen;
        // TODO: Remove when posting list format with interleaved features is made default
        bool _interleaved_features;

    public:
        IndexField(vespalib::stringref name, DataType dt) noexcept;
        IndexField(vespalib::stringref name, DataType dt, CollectionType ct) noexcept;
        IndexField(const IndexField &) noexcept;
        IndexField & operator = (const IndexField &) noexcept;
        IndexField(IndexField &&) noexcept;
        IndexField & operator = (IndexField &&) noexcept;
        /**
         * Create this index field based on the given config lines.
         **/
        explicit IndexField(const config::StringVector &lines);

        IndexField &setAvgElemLen(uint32_t avgElemLen) noexcept { _avgElemLen = avgElemLen; return *this; }
        IndexField &set_interleaved_features(bool value) noexcept {
            _interleaved_features = value;
            return *this;
        }

        void write(vespalib::asciistream &os,
                   vespalib::stringref prefix) const override;

        uint32_t getAvgElemLen() const noexcept { return _avgElemLen; }
        bool use_interleaved_features() const noexcept { return _interleaved_features; }

        bool operator==(const IndexField &rhs) const noexcept;
        bool operator!=(const IndexField &rhs) const noexcept;
    };

    using AttributeField = Field;
    using ImportedAttributeField = Field;

    /**
     * A field collection has a name and a list of index field names,
     * and is a named physical view over the list of index fields.
     **/
    class FieldSet
    {
        vespalib::string _name;
        std::vector<vespalib::string> _fields;

    public:
        explicit FieldSet(vespalib::stringref n) noexcept : _name(n), _fields() {}
        FieldSet(const FieldSet &);
        FieldSet & operator =(const FieldSet &);
        FieldSet(FieldSet &&) noexcept = default;
        FieldSet & operator =(FieldSet &&) noexcept = default;

        /**
         * Create this field collection based on the given config lines.
         **/
        explicit FieldSet(const config::StringVector & lines);

        ~FieldSet();

        FieldSet &addField(vespalib::stringref fieldName) {
            _fields.emplace_back(fieldName);
            return *this;
        }

        const vespalib::string &getName() const noexcept { return _name; }
        const std::vector<vespalib::string> &getFields() const noexcept { return _fields; }

        bool operator==(const FieldSet &rhs) const noexcept;
        bool operator!=(const FieldSet &rhs) const noexcept;
    };

    static const uint32_t UNKNOWN_FIELD_ID;

private:
    std::vector<IndexField>      _indexFields;
    std::vector<AttributeField>  _attributeFields;
    std::vector<FieldSet> _fieldSets;
    std::vector<ImportedAttributeField> _importedAttributeFields;
    using Name2IdMap = vespalib::hash_map<vespalib::string, uint32_t>;
    Name2IdMap _indexIds;
    Name2IdMap _attributeIds;
    Name2IdMap _fieldSetIds;
    Name2IdMap _importedAttributeIds;

    void writeToStream(vespalib::asciistream &os, bool saveToDisk) const;

public:
    /**
     * Create an initially empty schema
     **/
    Schema();
    Schema(const Schema & rhs);
    Schema & operator=(const Schema & rhs);
    Schema(Schema && rhs) noexcept;
    Schema & operator=(Schema && rhs) noexcept;
    ~Schema();

    /**
     * Load this schema from the file with the given name.
     *
     * @param fileName the name of the file.
     * @return true if the schema could be loaded.
     **/
    bool loadFromFile(const vespalib::string & fileName);

    /**
     * Save this schema to the file with the given name.
     *
     * @param fileName the name of the file.
     * @return true if the schema could be saved.
     **/
    bool saveToFile(const vespalib::string & fileName) const;

    vespalib::string toString() const;

    /**
     * Add an index field to this schema
     *
     * @param field the field to add
     **/
    Schema & addIndexField(const IndexField &field);

    // Only used by tests.
    Schema & addUriIndexFields(const IndexField &field);

    /**
     * Add an attribute field to this schema
     *
     * @param field the field to add
     **/
    Schema & addAttributeField(const AttributeField &field);

    /**
     * Add a field set to this schema.
     *
     * @param collection the field set to add.
     **/
    Schema & addFieldSet(const FieldSet &collection);

    Schema &addImportedAttributeField(const ImportedAttributeField &field);

    /**
     * Obtain the number of index fields in this schema.
     *
     * @return number of fields
     **/
    uint32_t getNumIndexFields() const noexcept { return _indexFields.size(); }

    /**
     * Obtain the number of attribute fields in this schema.
     *
     * @return number of fields
     **/
    uint32_t getNumAttributeFields() const noexcept { return _attributeFields.size(); }

    /**
     * Obtain the number of field sets in this schema.
     *
     * @return number of field sets.
     **/
    uint32_t getNumFieldSets() const noexcept { return _fieldSets.size(); }

    size_t getNumImportedAttributeFields() const noexcept { return _importedAttributeFields.size(); }

    /**
     * Get information about a specific index field using the given fieldId.
     *
     * @return the field
     * @param idx an index in the range [0, size - 1].
     **/
    const IndexField & getIndexField(uint32_t fieldId) const noexcept { return _indexFields[fieldId]; }

    /**
     * Returns const view of the index fields.
     */
    const std::vector<IndexField> &getIndexFields() const noexcept { return _indexFields; }

    /**
     * Get the field id for the index field with the given name.
     *
     * @return the field id or UNKNOWN_FIELD_ID if not found.
     * @param name the name of the field.
     **/
    uint32_t getIndexFieldId(vespalib::stringref name) const noexcept;

    /**
     * Check if a field is an index
     *
     * @return true if field is an index field.
     * @param name the name of the field.
     **/
    bool isIndexField(vespalib::stringref name) const noexcept;

    /**
     * Check if a field is a attribute field
     *
     * @return true if field is an attribute field.
     * @param name the name of the field.
     **/
    bool isAttributeField(vespalib::stringref name) const noexcept;

    /**
     * Get information about a specific attribute field using the given fieldId.
     *
     * @return the field
     * @param idx an index in the range [0, size - 1].
     **/
    const AttributeField & getAttributeField(uint32_t fieldId) const noexcept { return _attributeFields[fieldId]; }

    /**
     * Returns const view of the attribute fields.
     */
    const std::vector<AttributeField> &getAttributeFields() const noexcept { return _attributeFields; }

    /**
     * Get the field id for the attribute field with the given name.
     *
     * @return the field id or UNKNOWN_FIELD_ID if not found.
     * @param name the name of the field.
     **/
    uint32_t getAttributeFieldId(vespalib::stringref name) const noexcept;

    /**
     * Get information about a specific field set
     *
     * @return the field set.
     * @param idx an index in the range [0, size - 1].
     **/
    const FieldSet & getFieldSet(uint32_t idx) const noexcept { return _fieldSets[idx]; }

    /**
     * Get the field id for the field set with the given name.
     *
     * @return the field id or UNKNOWN_FIELD_ID if not found.
     * @param name the name of the field set.
     **/
    uint32_t getFieldSetId(vespalib::stringref name) const noexcept;

    const std::vector<ImportedAttributeField> &getImportedAttributeFields() const noexcept {
        return _importedAttributeFields;
    }

    void swap(Schema &rhs);
    void clear();

    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);

    bool operator==(const Schema &rhs) const noexcept ;
    bool operator!=(const Schema &rhs) const noexcept;

    bool empty() const noexcept;
};

}