[ https://issues.apache.org/jira/browse/DRILL-5547?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16083213#comment-16083213 ]
ASF GitHub Bot commented on DRILL-5547: --------------------------------------- Github user paul-rogers commented on a diff in the pull request: https://github.com/apache/drill/pull/868#discussion_r126835350 --- Diff: exec/java-exec/src/main/java/org/apache/drill/exec/store/sys/ExtendedOptionIterator.java --- @@ -0,0 +1,152 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF 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. + */ +package org.apache.drill.exec.store.sys; + +import java.util.Collections; +import java.util.Comparator; +import java.util.Iterator; +import java.util.List; +import java.util.Arrays; + +import com.google.common.collect.Iterators; +import com.google.common.collect.Lists; +import org.apache.drill.exec.ops.FragmentContext; +import org.apache.drill.exec.server.options.OptionManager; +import org.apache.drill.exec.server.options.OptionValue; +import org.apache.drill.exec.server.options.OptionValue.Kind; +import org.apache.drill.exec.server.options.OptionValue.OptionType; +import org.apache.drill.exec.server.options.SystemOptionManager; +/* + * To extend the original Option iterator to hide the implementation details and to return the row + * which takes precedence over others for an option.This is done by examining the type as the precendence + * order is session - system - default.All the values are represented as String instead of having multiple + * columns and the datatype is provided for type details. + */ +public class ExtendedOptionIterator implements Iterator<Object> { +// private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(OptionIterator.class); + + private final OptionManager fragmentOptions; + private final Iterator<OptionValue> mergedOptions; + + public ExtendedOptionIterator(FragmentContext context) { + fragmentOptions = context.getOptions(); + final Iterator<OptionValue> optionList; + mergedOptions = sortOptions(fragmentOptions.iterator()); + } + /* + Sort options according to name and the type to remove the redundant rows + for the same option based on the type + */ + public Iterator<OptionValue> sortOptions(Iterator<OptionValue> options) + { + List<OptionValue> values = Lists.newArrayList(options); + List<OptionValue> optionValues = Lists.newArrayList(); + List<OptionValue> optionValueList = Lists.newArrayList(); + OptionValue value; + OptionType type; + OptionValue[] temp = new OptionValue[3]; + + for (int i = 0; i < values.size(); i++){ + value = values.get(i); + final OptionValue def = SystemOptionManager.getValidator(value.name).getDefault(); + if (value.equalsIgnoreType(def)) { + type = OptionType.DEFAULT; + optionValueList.add(OptionValue.createOption(value.kind,type,value.name,value.getValue().toString())); + } else { + type = value.type; + optionValueList.add(OptionValue.createOption(value.kind,type,value.name,value.getValue().toString())); + } + } + Collections.sort(optionValueList, new Comparator<OptionValue>() { + @Override + public int compare(OptionValue v1, OptionValue v2) { + int nameCmp = v1.name.compareTo(v2.name); + if (nameCmp != 0) { + return nameCmp; + } + return v1.type.compareTo( v2.type); + } + }); + + for (int i = 0; i < optionValueList.size() ;i++ ) + { + value = optionValueList.get(i); + type = value.type ; + switch (type) { + case DEFAULT: + temp[2] = value; + break; + case SYSTEM: + temp[1] = value; + case SESSION: + temp[0] = value; + break; + } + if(i == optionValueList.size() - 1 || (i < optionValueList.size() && !value.getName().equals(optionValueList.get(i+1).getName()))) { + int j = 0; + while (temp[j] == null) { + j++; + } + optionValues.add(temp[j]); + Arrays.fill(temp,null); + } + } + return optionValues.iterator(); + } + + @Override + public boolean hasNext() { + return mergedOptions.hasNext(); + } + + @Override + public ExtendedOptionValueWrapper next() { + final OptionValue value = mergedOptions.next(); + return new ExtendedOptionValueWrapper(value.name, value.kind, value.type,value.getValue().toString()); + } + + public enum Status { + BOOT, DEFAULT, CHANGED + } + + /** + * Wrapper class for Extended Option Value + */ + public static class ExtendedOptionValueWrapper { + + public final String name; + public final Kind kind; + public final OptionType type; + public final String string_value; --- End diff -- string_value --> value Since this is a column name, might as well make it simple. Also, can we include the data type? Each validator can return its type. For example, LongValidator can return either `Long.class` (kind of messy), or `OptionDataType.LONG` (which is a bit less messy). Then, convert the internal type to a nice display name, perhaps mapping to the DrillType. So, a long becomes `Bigint` or `BIGINT`. > Drill config options and session options do not work as intended > ---------------------------------------------------------------- > > Key: DRILL-5547 > URL: https://issues.apache.org/jira/browse/DRILL-5547 > Project: Apache Drill > Issue Type: Bug > Components: Server > Affects Versions: 1.10.0 > Reporter: Karthikeyan Manivannan > Assignee: Venkata Jyothsna Donapati > Fix For: Future > > > In Drill, session options should take precedence over config options. But > several of these session options are assigned hard-coded default values when > the option validators are initialized. Because of this config options will > never be read and honored even if the user did not specify the session > option. > ClassCompilerSelector.JAVA_COMPILER_VALIDATOR uses CompilerPolicy.DEFAULT as > the default value. This default value gets into the session options map via > the initialization of validators in SystemOptionManager. > Now any piece of code that tries to check if a session option is set will > never see a null, so it will always use that value and never try to look into > the config options. For example, in the following piece of code from > ClassCompilerSelector (), the policy will never be read from the config file. > policy = CompilerPolicy.valueOf((value != null) ? > value.string_val.toUpperCase() : > config.getString(JAVA_COMPILER_CONFIG).toUpperCase()); -- This message was sent by Atlassian JIRA (v6.4.14#64029)