public static function wrapPrivateFieldQuery(Field $field, array $query)
{
if ($field->isPrivate()) {
return self::restrictQueryToCollections($query, $field->getDependantCollections());
} else {
return $query;
}
}
/**
* @todo Maybe we should put this logic in Field class?
*/
public function localizeField(Field $field)
{
$index_field = $field->getIndexField();
if ($field->getType() === Mapping::TYPE_STRING) {
return $this->localizeFieldName($index_field);
} else {
return [$index_field];
}
}
public static function wrapPrivateFieldAggregation(Field $field, array $aggregation)
{
if ($field->isPrivate()) {
$wrapper = [];
$wrapper['filter']['terms']['base_id'] = $field->getDependantCollections();
$wrapper['aggs']['__wrapped_private_field__'] = $aggregation;
return $wrapper;
} else {
return $aggregation;
}
}
public function add(Field $field)
{
$name = $field->getName();
if (isset($this->fields[$name])) {
$field = $this->fields[$name]->mergeWith($field);
}
$this->fields[$name] = $field;
if ($field->getType() === Mapping::TYPE_DATE) {
$this->date_fields[$name] = $field;
}
if ($field->isPrivate()) {
$this->private[$name] = $field;
}
if ($field->isFacet() && $field->isSearchable()) {
$this->facets[$name] = $field;
}
if ($field->hasConceptInference()) {
$this->thesaurus_fields[$name] = $field;
}
}
private function limitField(Field $field, array $allowed_collections = null)
{
if ($allowed_collections === null) {
$allowed_collections = $this->allowedCollections();
}
$collections = array_values(array_intersect($field->getDependantCollections(), $allowed_collections));
return $field->withOptions(['used_by_collections' => $collections]);
}
public function testCollectionsUsedByPrivateFields()
{
$structure = new Structure();
$structure->add($foo = new Field('foo', Mapping::TYPE_STRING, ['private' => true, 'used_by_collections' => [1, 2]]));
$structure->add(new Field('foo', Mapping::TYPE_STRING, ['private' => true, 'used_by_collections' => [2, 3]]));
$structure->add(new Field('bar', Mapping::TYPE_STRING, ['private' => true, 'used_by_collections' => [2, 3]]));
$structure->add(new Field('baz', Mapping::TYPE_STRING, ['private' => false]));
$this->assertEquals([1, 2], $foo->getDependantCollections());
static $expected = ['foo' => [1, 2, 3], 'bar' => [2, 3]];
$this->assertEquals($expected, $structure->getCollectionsUsedByPrivateFields());
}
/**
* Merge with another field, returning the new instance
*
* @param Field $other
* @return Field
* @throws MergeException
*/
public function mergeWith(Field $other)
{
if (($name = $other->getName()) !== $this->name) {
throw new MergeException(sprintf("Fields have different names (%s vs %s)", $this->name, $name));
}
// Since mapping is merged between databoxes, two fields may
// have conflicting names. Indexing is the same for a given
// type so we reject only those with different types.
if (($type = $other->getType()) !== $this->type) {
throw new MergeException(sprintf("Field %s can't be merged, incompatible types (%s vs %s)", $name, $type, $this->type));
}
if ($other->isPrivate() !== $this->is_private) {
throw new MergeException(sprintf("Field %s can't be merged, could not mix private and public fields with same name", $name));
}
if ($other->isSearchable() !== $this->is_searchable) {
throw new MergeException(sprintf("Field %s can't be merged, incompatible searchablility", $name));
}
if ($other->getFacetValuesLimit() !== $this->facet) {
throw new MergeException(sprintf("Field %s can't be merged, incompatible facet eligibility", $name));
}
$thesaurus_roots = null;
if ($this->thesaurus_roots !== null || $other->thesaurus_roots !== null) {
$thesaurus_roots = array_merge((array) $this->thesaurus_roots, (array) $other->thesaurus_roots);
}
$used_by_collections = array_values(array_unique(array_merge($this->used_by_collections, $other->used_by_collections), SORT_REGULAR));
return $this->withOptions(['thesaurus_roots' => $thesaurus_roots, 'used_by_collections' => $used_by_collections]);
}
public function testMergeWithDependantCollections()
{
$field = new Field('foo', Mapping::TYPE_STRING, ['used_by_collections' => [1, 2]]);
$other = new Field('foo', Mapping::TYPE_STRING, ['used_by_collections' => [2, 3]]);
$merged = $field->mergeWith($other);
$this->assertEquals([1, 2, 3], $merged->getDependantCollections());
}
private function addFieldToMapping(Field $field, Mapping $mapping)
{
$type = $field->getType();
$mapping->add($field->getName(), $type);
if ($type === Mapping::TYPE_DATE) {
$mapping->format(Mapping::DATE_FORMAT_CAPTION);
}
if ($type === Mapping::TYPE_STRING) {
$searchable = $field->isSearchable();
$facet = $field->isFacet();
if (!$searchable && !$facet) {
$mapping->notIndexed();
} else {
$mapping->addRawVersion();
$mapping->addAnalyzedVersion($this->locales);
$mapping->enableTermVectors(true);
}
}
}
