Apache HBase – Bulk Loads in Apache HBase (TM) @@ -305,7 +305,7 @@ under the License. --> <a href="http://www.apache.org/">The Apache Software Foundation</a>. All rights reserved. - <li id="publishDate" class="pull-right">Last Published: 2016-07-07</li> + <li id="publishDate" class="pull-right">Last Published: 2016-07-12</li> </p> </div>

001/*
-002 *
-003 * Licensed to the Apache Software Foundation (ASF) under one
-004 * or more contributor license agreements.  See the NOTICE file
-005 * distributed with this work for additional information
-006 * regarding copyright ownership.  The ASF licenses this file
-007 * to you under the Apache License, Version 2.0 (the
-008 * "License"); you may not use this file except in compliance
-009 * with the License.  You may obtain a copy of the License at
-010 *
-011 *     http://www.apache.org/licenses/LICENSE-2.0
-012 *
-013 * Unless required by applicable law or agreed to in writing, software
-014 * distributed under the License is distributed on an "AS IS" BASIS,
-015 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-016 * See the License for the specific language governing permissions and
-017 * limitations under the License.
-018 */
-019
-020package org.apache.hadoop.hbase.io;
-021
-022import java.io.IOException;
-023
-024import org.apache.hadoop.hbase.classification.InterfaceAudience;
-025import org.apache.hadoop.hbase.classification.InterfaceStability;
-026import org.apache.hadoop.hbase.util.Bytes;
-027
-028/**
-029 * Represents an interval of version timestamps.
-030 * <p>
-031 * Evaluated according to minStamp &lt;= timestamp &lt; maxStamp
-032 * or [minStamp,maxStamp) in interval notation.
-033 * <p>
-034 * Only used internally; should not be accessed directly by clients.
-035 */
-036@InterfaceAudience.Public
-037@InterfaceStability.Stable
-038public class TimeRange {
-039  static final long INITIAL_MIN_TIMESTAMP = 0l;
-040  private static final long MIN_TIME = INITIAL_MIN_TIMESTAMP;
-041  static final long INITIAL_MAX_TIMESTAMP = Long.MAX_VALUE;
-042  static final long MAX_TIME = INITIAL_MAX_TIMESTAMP;
-043  private long minStamp = MIN_TIME;
-044  private long maxStamp = MAX_TIME;
+002 * Licensed to the Apache Software Foundation (ASF) under one
+003 * or more contributor license agreements.  See the NOTICE file
+004 * distributed with this work for additional information
+005 * regarding copyright ownership.  The ASF licenses this file
+006 * to you under the Apache License, Version 2.0 (the
+007 * "License"); you may not use this file except in compliance
+008 * with the License.  You may obtain a copy of the License at
+009 *
+010 *     http://www.apache.org/licenses/LICENSE-2.0
+011 *
+012 * Unless required by applicable law or agreed to in writing, software
+013 * distributed under the License is distributed on an "AS IS" BASIS,
+014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+015 * See the License for the specific language governing permissions and
+016 * limitations under the License.
+017 */
+018
+019package org.apache.hadoop.hbase.io;
+020
+021import java.io.IOException;
+022
+023import org.apache.hadoop.hbase.classification.InterfaceAudience;
+024import org.apache.hadoop.hbase.classification.InterfaceStability;
+025import org.apache.hadoop.hbase.util.Bytes;
+026
+027/**
+028 * Represents an interval of version timestamps. Presumes timestamps between
+029 * {@link #INITIAL_MIN_TIMESTAMP} and {@link #INITIAL_MAX_TIMESTAMP} only. Gets freaked out if
+030 * passed a timestamp that is < {@link #INITIAL_MIN_TIMESTAMP},
+031 * <p>
+032 * Evaluated according to minStamp &lt;= timestamp &lt; maxStamp
+033 * or [minStamp,maxStamp) in interval notation.
+034 * <p>
+035 * Only used internally; should not be accessed directly by clients.
+036 *<p>Immutable. Thread-safe.
+037 */
+038@InterfaceAudience.Public
+039@InterfaceStability.Stable
+040public class TimeRange {
+041  public static final long INITIAL_MIN_TIMESTAMP = 0L;
+042  public static final long INITIAL_MAX_TIMESTAMP = Long.MAX_VALUE;
+043  private final long minStamp;
+044  private final long maxStamp;
 045  private final boolean allTime;
 046
 047  /**
 048   * Default constructor.
 049   * Represents interval [0, Long.MAX_VALUE) (allTime)
-050   */
-051  public TimeRange() {
-052    allTime = true;
-053  }
-054
-055  /**
-056   * Represents interval [minStamp, Long.MAX_VALUE)
-057   * @param minStamp the minimum timestamp value, inclusive
-058   */
-059  public TimeRange(long minStamp) {
-060    this.minStamp = minStamp;
-061    this.allTime = this.minStamp == MIN_TIME;
-062  }
-063
-064  /**
-065   * Represents interval [minStamp, Long.MAX_VALUE)
-066   * @param minStamp the minimum timestamp value, inclusive
-067   */
-068  public TimeRange(byte [] minStamp) {
-069    this.minStamp = Bytes.toLong(minStamp);
-070    this.allTime = false;
-071  }
-072
-073  /**
-074   * Represents interval [minStamp, maxStamp)
-075   * @param minStamp the minimum timestamp, inclusive
-076   * @param maxStamp the maximum timestamp, exclusive
-077   * @throws IllegalArgumentException
-078   */
-079  public TimeRange(long minStamp, long maxStamp) {
-080    if (minStamp < 0 || maxStamp < 0) {
-081      throw new IllegalArgumentException("Timestamp cannot be negative. minStamp:" + minStamp
-082        + ", maxStamp:" + maxStamp);
-083    }
-084    if (maxStamp < minStamp) {
-085      throw new IllegalArgumentException("maxStamp is smaller than minStamp");
-086    }
-087    this.minStamp = minStamp;
-088    this.maxStamp = maxStamp;
-089    this.allTime = this.minStamp == MIN_TIME && this.maxStamp == MAX_TIME;
-090  }
-091
-092  /**
-093   * Represents interval [minStamp, maxStamp)
-094   * @param minStamp the minimum timestamp, inclusive
-095   * @param maxStamp the maximum timestamp, exclusive
-096   * @throws IOException
-097   */
-098  public TimeRange(byte [] minStamp, byte [] maxStamp)
-099  throws IOException {
-100    this(Bytes.toLong(minStamp), Bytes.toLong(maxStamp));
+050   * @deprecated This is made @InterfaceAudience.Private in the 2.0 line and above
+051   */
+052  @Deprecated
+053  public TimeRange() {
+054    this(INITIAL_MIN_TIMESTAMP, INITIAL_MAX_TIMESTAMP);
+055  }
+056
+057  /**
+058   * Represents interval [minStamp, Long.MAX_VALUE)
+059   * @param minStamp the minimum timestamp value, inclusive
+060   * @deprecated This is made @InterfaceAudience.Private in the 2.0 line and above
+061   */
+062  @Deprecated
+063  public TimeRange(long minStamp) {
+064    this(minStamp, INITIAL_MAX_TIMESTAMP);
+065  }
+066
+067  /**
+068   * Represents interval [minStamp, Long.MAX_VALUE)
+069   * @param minStamp the minimum timestamp value, inclusive
+070   * @deprecated This is made @InterfaceAudience.Private in the 2.0 line and above
+071   */
+072  @Deprecated
+073  public TimeRange(byte [] minStamp) {
+074    this(Bytes.toLong(minStamp));
+075  }
+076
+077  /**
+078   * Represents interval [minStamp, maxStamp)
+079   * @param minStamp the minimum timestamp, inclusive
+080   * @param maxStamp the maximum timestamp, exclusive
+081   * @deprecated This is made @InterfaceAudience.Private in the 2.0 line and above
+082   */
+083  @Deprecated
+084  public TimeRange(byte [] minStamp, byte [] maxStamp) {
+085    this(Bytes.toLong(minStamp), Bytes.toLong(maxStamp));
+086  }
+087
+088  /**
+089   * Represents interval [minStamp, maxStamp)
+090   * @param minStamp the minimum timestamp, inclusive
+091   * @param maxStamp the maximum timestamp, exclusive
+092   * @throws IllegalArgumentException if either <0,
+093   * @deprecated This is made @InterfaceAudience.Private in the 2.0 line and above
+094   */
+095  @Deprecated
+096  public TimeRange(long minStamp, long maxStamp) {
+097    check(minStamp, maxStamp);
+098    this.minStamp = minStamp;
+099    this.maxStamp = maxStamp;
+100    this.allTime = isAllTime(minStamp, maxStamp);
 101  }
 102
-103  /**
-104   * @return the smallest timestamp that should be considered
-105   */
-106  public long getMin() {
-107    return minStamp;
-108  }
-109
-110  /**
-111   * @return the biggest timestamp that should be considered
-112   */
-113  public long getMax() {
-114    return maxStamp;
+103  private static boolean isAllTime(long minStamp, long maxStamp) {
+104    return minStamp == INITIAL_MIN_TIMESTAMP && maxStamp == INITIAL_MAX_TIMESTAMP;
+105  }
+106
+107  private static void check(long minStamp, long maxStamp) {
+108    if (minStamp < 0 || maxStamp < 0) {
+109      throw new IllegalArgumentException("Timestamp cannot be negative. minStamp:" + minStamp
+110        + ", maxStamp:" + maxStamp);
+111    }
+112    if (maxStamp < minStamp) {
+113      throw new IllegalArgumentException("maxStamp is smaller than minStamp");
+114    }
 115  }
 116
 117  /**
-118   * Check if it is for all time
-119   * @return true if it is for all time
-120   */
-121  public boolean isAllTime() {
-122    return allTime;
-123  }
-124
-125  /**
-126   * Check if the specified timestamp is within this TimeRange.
-127   * <p>
-128   * Returns true if within interval [minStamp, maxStamp), false
-129   * if not.
-130   * @param bytes timestamp to check
-131   * @param offset offset into the bytes
-132   * @return true if within TimeRange, false if not
-133   */
-134  public boolean withinTimeRange(byte [] bytes, int offset) {
-135    if(allTime) return true;
-136    return withinTimeRange(Bytes.toLong(bytes, offset));
+118   * @return the smallest timestamp that should be considered
+119   */
+120  public long getMin() {
+121    return minStamp;
+122  }
+123
+124  /**
+125   * @return the biggest timestamp that should be considered
+126   */
+127  public long getMax() {
+128    return maxStamp;
+129  }
+130
+131  /**
+132   * Check if it is for all time
+133   * @return true if it is for all time
+134   */
+135  public boolean isAllTime() {
+136    return allTime;
 137  }
 138
 139  /**
 140   * Check if the specified timestamp is within this TimeRange.
 141   * <p>
-142   * Returns true if within interval [minStamp, maxStamp), false
-143   * if not.
-144   * @param timestamp timestamp to check
+142   * Returns true if within interval [minStamp, maxStamp), false if not.
+143   * @param bytes timestamp to check
+144   * @param offset offset into the bytes
 145   * @return true if within TimeRange, false if not
 146   */
-147  public boolean withinTimeRange(long timestamp) {
-148    if (this.allTime) {
+147  public boolean withinTimeRange(byte [] bytes, int offset) {
+148    if (allTime) {
 149      return true;
 150    }
-151    // check if >= minStamp
-152    return (minStamp <= timestamp && timestamp < maxStamp);
-153  }
-154
-155  /**
-156   * Check if the range has any overlap with TimeRange
-157   * @param tr TimeRange
-158   * @return True if there is overlap, false otherwise
-159   */
-160  // This method came from TimeRangeTracker. We used to go there for this function but better
-161  // to come here to the immutable, unsynchronized datastructure at read time.
-162  public boolean includesTimeRange(final TimeRange tr) {
-163    if (this.allTime) {
-164      return true;
-165    }
-166    return getMin() < tr.getMax() && getMax() >= tr.getMin();
-167  }
-168
-169  /**
-170   * Check if the specified timestamp is within this TimeRange.
-171   * <p>
-172   * Returns true if within interval [minStamp, maxStamp), false
-173   * if not.
-174   * @param timestamp timestamp to check
-175   * @return true if within TimeRange, false if not
-176   */
-177  public boolean withinOrAfterTimeRange(long timestamp) {
-178    if(allTime) return true;
-179    // check if >= minStamp
-180    return (timestamp >= minStamp);
-181  }
-182
-183  /**
-184   * Compare the timestamp to timerange
-185   * @param timestamp
-186   * @return -1 if timestamp is less than timerange,
-187   * 0 if timestamp is within timerange,
-188   * 1 if timestamp is greater than timerange
-189   */
-190  public int compare(long timestamp) {
-191    if (allTime) return 0;
-192    if (timestamp < minStamp) {
-193      return -1;
-194    } else if (timestamp >= maxStamp) {
-195      return 1;
-196    } else {
-197      return 0;
+151    return withinTimeRange(Bytes.toLong(bytes, offset));
+152  }
+153
+154  /**
+155   * Check if the specified timestamp is within this TimeRange.
+156   * <p>
+157   * Returns true if within interval [minStamp, maxStamp), false
+158   * if not.
+159   * @param timestamp timestamp to check
+160   * @return true if within TimeRange, false if not
+161   */
+162  public boolean withinTimeRange(long timestamp) {
+163    assert timestamp >= 0;
+164    if (this.allTime) {
+165      return true;
+166    }
+167    // check if >= minStamp
+168    return (minStamp <= timestamp && timestamp < maxStamp);
+169  }
+170
+171  /**
+172   * Check if the range has any overlap with TimeRange
+173   * @param tr TimeRange
+174   * @return True if there is overlap, false otherwise
+175   */
+176  // This method came from TimeRangeTracker. We used to go there for this function but better
+177  // to come here to the immutable, unsynchronized datastructure at read time.
+178  public boolean includesTimeRange(final TimeRange tr) {
+179    if (this.allTime) {
+180      return true;
+181    }
+182    assert tr.getMin() >= 0;
+183    return getMin() < tr.getMax() && getMax() >= tr.getMin();
+184  }
+185
+186  /**
+187   * Check if the specified timestamp is within this TimeRange.
+188   * <p>
+189   * Returns true if within interval [minStamp, maxStamp), false
+190   * if not.
+191   * @param timestamp timestamp to check
+192   * @return true if within TimeRange, false if not
+193   */
+194  public boolean withinOrAfterTimeRange(long timestamp) {
+195    assert timestamp >= 0;
+196    if (allTime) {
+197      return true;
 198    }
-199  }
-200
-201  @Override
-202  public String toString() {
-203    StringBuilder sb = new StringBuilder();
-204    sb.append("maxStamp=");
-205    sb.append(this.maxStamp);
-206    sb.append(", minStamp=");
-207    sb.append(this.minStamp);
-208    return sb.toString();
-209  }
-210}
+199    // check if >= minStamp
+200    return timestamp >= minStamp;
+201  }
+202
+203  /**
+204   * Compare the timestamp to timerange.
+205   * @return -1 if timestamp is less than timerange,
+206   * 0 if timestamp is within timerange,
+207   * 1 if timestamp is greater than timerange
+208   */
+209  public int compare(long timestamp) {
+210    assert timestamp >= 0;
+211    if (this.allTime) {
+212      return 0;
+213    }
+214    if (timestamp < minStamp) {
+215      return -1;
+216    }
+217    return timestamp >= maxStamp? 1: 0;
+218  }
+219
+220  @Override
+221  public String toString() {
+222    StringBuilder sb = new StringBuilder();
+223    sb.append("maxStamp=");
+224    sb.append(this.maxStamp);
+225    sb.append(", minStamp=");
+226    sb.append(this.minStamp);
+227    return sb.toString();
+228  }
+229}
 
 
 

http://git-wip-us.apache.org/repos/asf/hbase-site/blob/27849820/book.html
----------------------------------------------------------------------
diff --git a/book.html b/book.html
index e3bf5ee..3e5793e 100644
--- a/book.html
+++ b/book.html
@@ -19477,7 +19477,14 @@ The value contains four pieces of information which are separated by the pipe (<
 File path: The jar file containing the Coprocessor implementation must be in a location where
 all region servers can read it.

 You could copy the file onto the local disk on each region server, but it is recommended to store
-it in HDFS.
+it in HDFS.

+HBASE-14548 allows a directory containing the jars
+or some wildcards to be specified, such as: hdfs://<namenode>:<port>/user/<hadoop-user>/ or
+hdfs://<namenode>:<port>/user/<hadoop-user>/*.jar. Please note that if a directory is specified,
+all jar files(.jar) directly in the directory are added,
+but it does not search files in the subtree rooted in the directory.
+And do not contain any wildcard if you would like to specify a directory.
+This enhancement applies to the ways of using the JAVA API as well.
 
 
 Class name: The full class name of the Coprocessor.
@@ -33766,7 +33773,7 @@ The server will return cellblocks compressed using this same compressor as long
 
 
 Version 2.0.0-SNAPSHOT

-Last updated 2016-04-08 14:30:12 UTC
+Last updated 2016-06-15 16:11:32 UTC
 
 
 

http://git-wip-us.apache.org/repos/asf/hbase-site/blob/27849820/bulk-loads.html
----------------------------------------------------------------------
diff --git a/bulk-loads.html b/bulk-loads.html
index 6716f87..6b09bad 100644
--- a/bulk-loads.html
+++ b/bulk-loads.html
@@ -7,7 +7,7 @@
   
     
     
-    
+    
     
     Apache HBase –  
       Bulk Loads in Apache HBase (TM)
@@ -305,7 +305,7 @@ under the License. -->
                         <a href="http://www.apache.org/">The Apache Software Foundation</a>.
             All rights reserved.      
                     
-                  <li id="publishDate" class="pull-right">Last Published: 2016-07-07</li>
+                  <li id="publishDate" class="pull-right">Last Published: 2016-07-12</li>
             </p>
                 </div>