io.crate.metadata.PartitionInfos.java Source code

Introduction

Here is the source code for io.crate.metadata.PartitionInfos.java

Source

/*
 * Licensed to CRATE Technology GmbH ("Crate") under one or more contributor
 * license agreements.  See the NOTICE file distributed with this work for
 * additional information regarding copyright ownership.  Crate licenses
 * this file to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.  You may
 * obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * However, if you have executed another commercial license agreement
 * with Crate these terms will supersede the license and you may use the
 * software solely pursuant to the terms of the relevant commercial agreement.
 */

package io.crate.metadata;

import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.FluentIterable;
import io.crate.Constants;
import io.crate.analyze.NumberOfReplicas;
import io.crate.analyze.TableParameterInfo;
import io.crate.metadata.doc.PartitionedByMappingExtractor;
import io.crate.types.DataType;
import io.crate.types.DataTypes;
import org.apache.lucene.util.BytesRef;
import org.elasticsearch.cluster.ClusterService;
import org.elasticsearch.cluster.metadata.IndexMetaData;
import org.elasticsearch.cluster.metadata.MappingMetaData;
import org.elasticsearch.common.collect.Tuple;
import org.elasticsearch.common.logging.Loggers;
import org.elasticsearch.common.lucene.BytesRefs;

import javax.annotation.Nullable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class PartitionInfos implements Iterable<PartitionInfo> {

    private static final Predicate<ObjectObjectCursor<String, IndexMetaData>> PARTITION_INDICES_PREDICATE = new Predicate<ObjectObjectCursor<String, IndexMetaData>>() {
        @Override
        public boolean apply(@Nullable ObjectObjectCursor<String, IndexMetaData> input) {
            return input != null && input.value.getState() == IndexMetaData.State.OPEN
                    && PartitionName.isPartition(input.key);
        }
    };

    private static final Function<ObjectObjectCursor<String, IndexMetaData>, PartitionInfo> CREATE_PARTITION_INFO_FUNCTION = new Function<ObjectObjectCursor<String, IndexMetaData>, PartitionInfo>() {
        @Nullable
        @Override
        public PartitionInfo apply(@Nullable ObjectObjectCursor<String, IndexMetaData> input) {
            assert input != null;
            PartitionName partitionName = PartitionName.fromIndexOrTemplate(input.key);
            try {
                Map<String, Object> valuesMap = buildValuesMap(partitionName,
                        input.value.mapping(Constants.DEFAULT_MAPPING_TYPE));
                BytesRef numberOfReplicas = NumberOfReplicas.fromSettings(input.value.getSettings());
                return new PartitionInfo(partitionName, input.value.getNumberOfShards(), numberOfReplicas,
                        valuesMap, TableParameterInfo.tableParametersFromIndexMetaData(input.value));
            } catch (Exception e) {
                Loggers.getLogger(PartitionInfos.class).trace("error extracting partition infos from index {}", e,
                        input.key);
                return null; // must filter on null
            }

        }
    };

    private final ClusterService clusterService;

    public PartitionInfos(ClusterService clusterService) {
        this.clusterService = clusterService;
    }

    @Override
    public Iterator<PartitionInfo> iterator() {
        // get a fresh one for each iteration
        return FluentIterable.from(clusterService.state().metaData().indices()).filter(PARTITION_INDICES_PREDICATE)
                .transform(CREATE_PARTITION_INFO_FUNCTION).filter(Predicates.notNull()).iterator();
    }

    @Nullable
    private static Map<String, Object> buildValuesMap(PartitionName partitionName, MappingMetaData mappingMetaData)
            throws Exception {
        int i = 0;
        Map<String, Object> valuesMap = new HashMap<>();
        Iterable<Tuple<ColumnIdent, DataType>> partitionColumnInfoIterable = PartitionedByMappingExtractor
                .extractPartitionedByColumns(mappingMetaData.sourceAsMap());
        for (Tuple<ColumnIdent, DataType> columnInfo : partitionColumnInfoIterable) {
            String columnName = columnInfo.v1().sqlFqn();
            // produce string type values as string, not bytesref
            Object value = BytesRefs.toString(partitionName.values().get(i));
            if (!columnInfo.v2().equals(DataTypes.STRING)) {
                value = columnInfo.v2().value(value);
            }
            valuesMap.put(columnName, value);
            i++;
        }
        return valuesMap;
    }
}