[Iceberg] Add Histogram Statistic Support

presto-common/src/main/java/com/facebook/presto/common/Utils.java

@@ -18,8 +18,15 @@
 import com.facebook.presto.common.predicate.Primitives;
 import com.facebook.presto.common.type.Type;
 
+import javax.annotation.Nullable;
+
+import java.util.Arrays;
+import java.util.function.Supplier;
+
 import static com.facebook.presto.common.type.TypeUtils.readNativeValue;
 import static com.facebook.presto.common.type.TypeUtils.writeNativeValue;
+import static java.lang.String.format;
+import static java.util.Objects.requireNonNull;
 
 public final class Utils
 {
@@ -30,7 +37,7 @@ private Utils()
     public static Block nativeValueToBlock(Type type, Object object)
     {
         if (object != null && !Primitives.wrap(type.getJavaType()).isInstance(object)) {
-            throw new IllegalArgumentException(String.format("Object '%s' does not match type %s", object, type.getJavaType()));
+            throw new IllegalArgumentException(format("Object '%s' does not match type %s", object, type.getJavaType()));
         }
         BlockBuilder blockBuilder = type.createBlockBuilder(null, 1);
         writeNativeValue(type, blockBuilder, object);
@@ -49,10 +56,201 @@ public static void checkArgument(boolean expression)
         }
     }
 
-    public static void checkArgument(boolean expression, String errorMessage)
+    public static void checkArgument(boolean expression, String message, Object... args)
     {
         if (!expression) {
-            throw new IllegalArgumentException(errorMessage);
+            throw new IllegalArgumentException(format(message, args));
+        }
+    }
+
+    /**
+     * Returns a supplier which caches the instance retrieved during the first call to {@code get()}
+     * and returns that value on subsequent calls to {@code get()}.
+     */
+    public static <T> Supplier<T> memoizedSupplier(Supplier<T> delegate)
+    {
+        if (delegate instanceof MemoizingSupplier) {
+            return delegate;
+        }
+        return new MemoizingSupplier<>(delegate);
+    }
+
+    /**
+     * Vendored from Guava
+     */
+    static class MemoizingSupplier<T>
+            implements Supplier<T>
+    {
+        volatile Supplier<T> delegate;
+        volatile boolean initialized;
+        // "value" does not need to be volatile; visibility piggy-backs
+        // on volatile read of "initialized".
+        @Nullable T value;
+
+        MemoizingSupplier(Supplier<T> delegate)
+        {
+            this.delegate = requireNonNull(delegate);
+        }
+
+        @Override
+        public T get()
+        {
+            // A 2-field variant of Double Checked Locking.
+            if (!initialized) {
+                synchronized (this) {
+                    if (!initialized) {
+                        T t = delegate.get();
+                        value = t;
+                        initialized = true;
+                        // Release the delegate to GC.
+                        delegate = null;
+                        return t;
+                    }
+                }
+            }
+            return value;
+        }
+
+        @Override
+        public String toString()
+        {
+            Supplier<T> delegate = this.delegate;
+            return "Suppliers.memoize("
+                    + (delegate == null ? "<supplier that returned " + value + ">" : delegate)
+                    + ")";
+        }
+    }
+
+    public static ToStringHelper toStringHelper(Object self)
+    {
+        return new ToStringHelper(self.getClass().getSimpleName());
+    }
+
+    public static ToStringHelper toStringHelper(Class<?> self)
+    {
+        return new ToStringHelper(self.getSimpleName());
+    }
+
+    public static ToStringHelper toStringHelper(String className)
+    {
+        return new ToStringHelper(className);
+    }
+
+    /**
+     * Vendored class from Guava.
+     */
+    public static final class ToStringHelper
+    {
+        private final String className;
+        private final ValueHolder holderHead = new ValueHolder();
+        private ValueHolder holderTail = holderHead;
+        private boolean omitNullValues;
+
+        private ToStringHelper(String className)
+        {
+            this.className = requireNonNull(className);
+        }
+
+        public ToStringHelper omitNullValues()
+        {
+            omitNullValues = true;
+            return this;
+        }
+
+        public ToStringHelper add(String name, @Nullable Object value)
+        {
+            return addHolder(name, value);
+        }
+
+        public ToStringHelper add(String name, boolean value)
+        {
+            return addHolder(name, String.valueOf(value));
+        }
+
+        public ToStringHelper add(String name, char value)
+        {
+            return addHolder(name, String.valueOf(value));
+        }
+
+        public ToStringHelper add(String name, double value)
+        {
+            return addHolder(name, String.valueOf(value));
+        }
+
+        public ToStringHelper add(String name, float value)
+        {
+            return addHolder(name, String.valueOf(value));
+        }
+
+        public ToStringHelper add(String name, int value)
+        {
+            return addHolder(name, String.valueOf(value));
+        }
+
+        public ToStringHelper add(String name, long value)
+        {
+            return addHolder(name, String.valueOf(value));
+        }
+
+        @Override
+        public String toString()
+        {
+            // create a copy to keep it consistent in case value changes
+            boolean omitNullValuesSnapshot = omitNullValues;
+            String nextSeparator = "";
+            StringBuilder builder = new StringBuilder(32).append(className).append('{');
+            for (ValueHolder valueHolder = holderHead.next;
+                    valueHolder != null;
+                    valueHolder = valueHolder.next) {
+                Object value = valueHolder.value;
+                if (!omitNullValuesSnapshot || value != null) {
+                    builder.append(nextSeparator);
+                    nextSeparator = ", ";
+
+                    if (valueHolder.name != null) {
+                        builder.append(valueHolder.name).append('=');
+                    }
+                    if (value != null && value.getClass().isArray()) {
+                        Object[] objectArray = {value};
+                        String arrayString = Arrays.deepToString(objectArray);
+                        builder.append(arrayString, 1, arrayString.length() - 1);
+                    }
+                    else {
+                        builder.append(value);
+                    }
+                }
+            }
+            return builder.append('}').toString();
+        }
+
+        private ValueHolder addHolder()
+        {
+            ValueHolder valueHolder = new ValueHolder();
+            holderTail.next = valueHolder;
+            holderTail = valueHolder;
+            return valueHolder;
+        }
+
+        private ToStringHelper addHolder(@Nullable Object value)
+        {
+            ValueHolder valueHolder = addHolder();
+            valueHolder.value = value;
+            return this;
+        }
+
+        private ToStringHelper addHolder(String name, @Nullable Object value)
+        {
+            ValueHolder valueHolder = addHolder();
+            valueHolder.value = value;
+            valueHolder.name = requireNonNull(name);
+            return this;
+        }
+
+        private static final class ValueHolder
+        {
+            @Nullable String name;
+            @Nullable Object value;
+            @Nullable ValueHolder next;
         }
     }
 }

presto-common/src/main/java/com/facebook/presto/common/predicate/Marker.java

@@ -129,6 +129,11 @@ public Object getValue()
         return Utils.blockToNativeValue(type, valueBlock.get());
     }
 
+    public Optional<Object> getObjectValue()
+    {
+        return valueBlock.map(block -> Utils.blockToNativeValue(type, block));
+    }
+
     public Object getPrintableValue(SqlFunctionProperties properties)
     {
         if (!valueBlock.isPresent()) {

presto-common/src/main/java/com/facebook/presto/common/predicate/Range.java

@@ -247,6 +247,16 @@ public boolean equals(Object obj)
                 Objects.equals(this.high, other.high);
     }
 
+    @Override
+    public String toString()
+    {
+        return (low.getBound() == Marker.Bound.EXACTLY ? "[" : "(") +
+                low.getObjectValue().orElse(Double.NEGATIVE_INFINITY) +
+                ".." +
+                high.getObjectValue().orElse(Double.POSITIVE_INFINITY) +
+                (high.getBound() == Marker.Bound.EXACTLY ? "]" : ")");
+    }
+
     private void appendQuotedValue(StringBuilder buffer, Marker marker, SqlFunctionProperties properties)
     {
         buffer.append('"');

presto-common/src/main/java/com/facebook/presto/common/predicate/SortedRangeSet.java

@@ -168,6 +168,28 @@ public Object getSingleValue()
         return lowIndexedRanges.values().iterator().next().getSingleValue();
     }
 
+    /**
+     * Build a new {@link SortedRangeSet} that contains ranges which lie within the argument range
+     *
+     * @param span the range which the new set should span
+     * @return a new range set
+     */
+    public SortedRangeSet subRangeSet(Range span)
+    {
+        Builder builder = new Builder(type);
+
+        for (Range range : getOrderedRanges()) {
+            if (span.contains(range)) {
+                builder.add(range);
+            }
+            else if (span.overlaps(range)) {
+                builder.add(range.intersect(span));
+            }
+        }
+
+        return builder.build();
+    }
+
     @Override
     public boolean containsValue(Object value)
     {