http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/generated/PTableProtos.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/generated/PTableProtos.java b/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/generated/PTableProtos.java index b8b8b2f..2f0c00b 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/generated/PTableProtos.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/generated/PTableProtos.java @@ -269,6 +269,16 @@ public final class PTableProtos { * <code>optional bool isDynamic = 14;</code> */ boolean getIsDynamic(); + + // optional int32 columnQualifier = 15; + /** + * <code>optional int32 columnQualifier = 15;</code> + */ + boolean hasColumnQualifier(); + /** + * <code>optional int32 columnQualifier = 15;</code> + */ + int getColumnQualifier(); } /** * Protobuf type {@code PColumn} @@ -391,6 +401,11 @@ public final class PTableProtos { isDynamic_ = input.readBool(); break; } + case 120: { + bitField0_ |= 0x00004000; + columnQualifier_ = input.readInt32(); + break; + } } } } catch (com.google.protobuf.InvalidProtocolBufferException e) { @@ -709,6 +724,22 @@ public final class PTableProtos { return isDynamic_; } + // optional int32 columnQualifier = 15; + public static final int COLUMNQUALIFIER_FIELD_NUMBER = 15; + private int columnQualifier_; + /** + * <code>optional int32 columnQualifier = 15;</code> + */ + public boolean hasColumnQualifier() { + return ((bitField0_ & 0x00004000) == 0x00004000); + } + /** + * <code>optional int32 columnQualifier = 15;</code> + */ + public int getColumnQualifier() { + return columnQualifier_; + } + private void initFields() { columnNameBytes_ = com.google.protobuf.ByteString.EMPTY; familyNameBytes_ = com.google.protobuf.ByteString.EMPTY; @@ -724,6 +755,7 @@ public final class PTableProtos { expression_ = ""; isRowTimestamp_ = false; isDynamic_ = false; + columnQualifier_ = 0; } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -799,6 +831,9 @@ public final class PTableProtos { if (((bitField0_ & 0x00002000) == 0x00002000)) { output.writeBool(14, isDynamic_); } + if (((bitField0_ & 0x00004000) == 0x00004000)) { + output.writeInt32(15, columnQualifier_); + } getUnknownFields().writeTo(output); } @@ -864,6 +899,10 @@ public final class PTableProtos { size += com.google.protobuf.CodedOutputStream .computeBoolSize(14, isDynamic_); } + if (((bitField0_ & 0x00004000) == 0x00004000)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(15, columnQualifier_); + } size += getUnknownFields().getSerializedSize(); memoizedSerializedSize = size; return size; @@ -957,6 +996,11 @@ public final class PTableProtos { result = result && (getIsDynamic() == other.getIsDynamic()); } + result = result && (hasColumnQualifier() == other.hasColumnQualifier()); + if (hasColumnQualifier()) { + result = result && (getColumnQualifier() + == other.getColumnQualifier()); + } result = result && getUnknownFields().equals(other.getUnknownFields()); return result; @@ -1026,6 +1070,10 @@ public final class PTableProtos { hash = (37 * hash) + ISDYNAMIC_FIELD_NUMBER; hash = (53 * hash) + hashBoolean(getIsDynamic()); } + if (hasColumnQualifier()) { + hash = (37 * hash) + COLUMNQUALIFIER_FIELD_NUMBER; + hash = (53 * hash) + getColumnQualifier(); + } hash = (29 * hash) + getUnknownFields().hashCode(); memoizedHashCode = hash; return hash; @@ -1163,6 +1211,8 @@ public final class PTableProtos { bitField0_ = (bitField0_ & ~0x00001000); isDynamic_ = false; bitField0_ = (bitField0_ & ~0x00002000); + columnQualifier_ = 0; + bitField0_ = (bitField0_ & ~0x00004000); return this; } @@ -1247,6 +1297,10 @@ public final class PTableProtos { to_bitField0_ |= 0x00002000; } result.isDynamic_ = isDynamic_; + if (((from_bitField0_ & 0x00004000) == 0x00004000)) { + to_bitField0_ |= 0x00004000; + } + result.columnQualifier_ = columnQualifier_; result.bitField0_ = to_bitField0_; onBuilt(); return result; @@ -1309,6 +1363,9 @@ public final class PTableProtos { if (other.hasIsDynamic()) { setIsDynamic(other.getIsDynamic()); } + if (other.hasColumnQualifier()) { + setColumnQualifier(other.getColumnQualifier()); + } this.mergeUnknownFields(other.getUnknownFields()); return this; } @@ -1909,6 +1966,39 @@ public final class PTableProtos { return this; } + // optional int32 columnQualifier = 15; + private int columnQualifier_ ; + /** + * <code>optional int32 columnQualifier = 15;</code> + */ + public boolean hasColumnQualifier() { + return ((bitField0_ & 0x00004000) == 0x00004000); + } + /** + * <code>optional int32 columnQualifier = 15;</code> + */ + public int getColumnQualifier() { + return columnQualifier_; + } + /** + * <code>optional int32 columnQualifier = 15;</code> + */ + public Builder setColumnQualifier(int value) { + bitField0_ |= 0x00004000; + columnQualifier_ = value; + onChanged(); + return this; + } + /** + * <code>optional int32 columnQualifier = 15;</code> + */ + public Builder clearColumnQualifier() { + bitField0_ = (bitField0_ & ~0x00004000); + columnQualifier_ = 0; + onChanged(); + return this; + } + // @@protoc_insertion_point(builder_scope:PColumn) } @@ -3372,6 +3462,41 @@ public final class PTableProtos { * <code>optional bytes parentNameBytes = 33;</code> */ com.google.protobuf.ByteString getParentNameBytes(); + + // optional bytes storageScheme = 34; + /** + * <code>optional bytes storageScheme = 34;</code> + */ + boolean hasStorageScheme(); + /** + * <code>optional bytes storageScheme = 34;</code> + */ + com.google.protobuf.ByteString getStorageScheme(); + + // repeated .EncodedCQCounter encodedCQCounters = 35; + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + java.util.List<org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter> + getEncodedCQCountersList(); + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter getEncodedCQCounters(int index); + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + int getEncodedCQCountersCount(); + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + java.util.List<? extends org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder> + getEncodedCQCountersOrBuilderList(); + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder getEncodedCQCountersOrBuilder( + int index); } /** * Protobuf type {@code PTable} @@ -3407,6 +3532,7 @@ public final class PTableProtos { throws com.google.protobuf.InvalidProtocolBufferException { initFields(); int mutable_bitField0_ = 0; + int mutable_bitField1_ = 0; com.google.protobuf.UnknownFieldSet.Builder unknownFields = com.google.protobuf.UnknownFieldSet.newBuilder(); try { @@ -3599,6 +3725,19 @@ public final class PTableProtos { parentNameBytes_ = input.readBytes(); break; } + case 274: { + bitField0_ |= 0x20000000; + storageScheme_ = input.readBytes(); + break; + } + case 282: { + if (!((mutable_bitField1_ & 0x00000002) == 0x00000002)) { + encodedCQCounters_ = new java.util.ArrayList<org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter>(); + mutable_bitField1_ |= 0x00000002; + } + encodedCQCounters_.add(input.readMessage(org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.PARSER, extensionRegistry)); + break; + } } } } catch (com.google.protobuf.InvalidProtocolBufferException e) { @@ -3616,6 +3755,9 @@ public final class PTableProtos { if (((mutable_bitField0_ & 0x00020000) == 0x00020000)) { physicalNames_ = java.util.Collections.unmodifiableList(physicalNames_); } + if (((mutable_bitField1_ & 0x00000002) == 0x00000002)) { + encodedCQCounters_ = java.util.Collections.unmodifiableList(encodedCQCounters_); + } this.unknownFields = unknownFields.build(); makeExtensionsImmutable(); } @@ -4275,6 +4417,58 @@ public final class PTableProtos { return parentNameBytes_; } + // optional bytes storageScheme = 34; + public static final int STORAGESCHEME_FIELD_NUMBER = 34; + private com.google.protobuf.ByteString storageScheme_; + /** + * <code>optional bytes storageScheme = 34;</code> + */ + public boolean hasStorageScheme() { + return ((bitField0_ & 0x20000000) == 0x20000000); + } + /** + * <code>optional bytes storageScheme = 34;</code> + */ + public com.google.protobuf.ByteString getStorageScheme() { + return storageScheme_; + } + + // repeated .EncodedCQCounter encodedCQCounters = 35; + public static final int ENCODEDCQCOUNTERS_FIELD_NUMBER = 35; + private java.util.List<org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter> encodedCQCounters_; + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public java.util.List<org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter> getEncodedCQCountersList() { + return encodedCQCounters_; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public java.util.List<? extends org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder> + getEncodedCQCountersOrBuilderList() { + return encodedCQCounters_; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public int getEncodedCQCountersCount() { + return encodedCQCounters_.size(); + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter getEncodedCQCounters(int index) { + return encodedCQCounters_.get(index); + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder getEncodedCQCountersOrBuilder( + int index) { + return encodedCQCounters_.get(index); + } + private void initFields() { schemaNameBytes_ = com.google.protobuf.ByteString.EMPTY; tableNameBytes_ = com.google.protobuf.ByteString.EMPTY; @@ -4308,6 +4502,8 @@ public final class PTableProtos { autoParititonSeqName_ = ""; isAppendOnlySchema_ = false; parentNameBytes_ = com.google.protobuf.ByteString.EMPTY; + storageScheme_ = com.google.protobuf.ByteString.EMPTY; + encodedCQCounters_ = java.util.Collections.emptyList(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -4362,6 +4558,12 @@ public final class PTableProtos { return false; } } + for (int i = 0; i < getEncodedCQCountersCount(); i++) { + if (!getEncodedCQCounters(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } memoizedIsInitialized = 1; return true; } @@ -4465,6 +4667,12 @@ public final class PTableProtos { if (((bitField0_ & 0x10000000) == 0x10000000)) { output.writeBytes(33, parentNameBytes_); } + if (((bitField0_ & 0x20000000) == 0x20000000)) { + output.writeBytes(34, storageScheme_); + } + for (int i = 0; i < encodedCQCounters_.size(); i++) { + output.writeMessage(35, encodedCQCounters_.get(i)); + } getUnknownFields().writeTo(output); } @@ -4607,6 +4815,14 @@ public final class PTableProtos { size += com.google.protobuf.CodedOutputStream .computeBytesSize(33, parentNameBytes_); } + if (((bitField0_ & 0x20000000) == 0x20000000)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(34, storageScheme_); + } + for (int i = 0; i < encodedCQCounters_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(35, encodedCQCounters_.get(i)); + } size += getUnknownFields().getSerializedSize(); memoizedSerializedSize = size; return size; @@ -4781,6 +4997,13 @@ public final class PTableProtos { result = result && getParentNameBytes() .equals(other.getParentNameBytes()); } + result = result && (hasStorageScheme() == other.hasStorageScheme()); + if (hasStorageScheme()) { + result = result && getStorageScheme() + .equals(other.getStorageScheme()); + } + result = result && getEncodedCQCountersList() + .equals(other.getEncodedCQCountersList()); result = result && getUnknownFields().equals(other.getUnknownFields()); return result; @@ -4922,6 +5145,14 @@ public final class PTableProtos { hash = (37 * hash) + PARENTNAMEBYTES_FIELD_NUMBER; hash = (53 * hash) + getParentNameBytes().hashCode(); } + if (hasStorageScheme()) { + hash = (37 * hash) + STORAGESCHEME_FIELD_NUMBER; + hash = (53 * hash) + getStorageScheme().hashCode(); + } + if (getEncodedCQCountersCount() > 0) { + hash = (37 * hash) + ENCODEDCQCOUNTERS_FIELD_NUMBER; + hash = (53 * hash) + getEncodedCQCountersList().hashCode(); + } hash = (29 * hash) + getUnknownFields().hashCode(); memoizedHashCode = hash; return hash; @@ -5025,6 +5256,7 @@ public final class PTableProtos { if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { getColumnsFieldBuilder(); getIndexesFieldBuilder(); + getEncodedCQCountersFieldBuilder(); } } private static Builder create() { @@ -5105,6 +5337,14 @@ public final class PTableProtos { bitField0_ = (bitField0_ & ~0x40000000); parentNameBytes_ = com.google.protobuf.ByteString.EMPTY; bitField0_ = (bitField0_ & ~0x80000000); + storageScheme_ = com.google.protobuf.ByteString.EMPTY; + bitField1_ = (bitField1_ & ~0x00000001); + if (encodedCQCountersBuilder_ == null) { + encodedCQCounters_ = java.util.Collections.emptyList(); + bitField1_ = (bitField1_ & ~0x00000002); + } else { + encodedCQCountersBuilder_.clear(); + } return this; } @@ -5132,6 +5372,7 @@ public final class PTableProtos { public org.apache.phoenix.coprocessor.generated.PTableProtos.PTable buildPartial() { org.apache.phoenix.coprocessor.generated.PTableProtos.PTable result = new org.apache.phoenix.coprocessor.generated.PTableProtos.PTable(this); int from_bitField0_ = bitField0_; + int from_bitField1_ = bitField1_; int to_bitField0_ = 0; if (((from_bitField0_ & 0x00000001) == 0x00000001)) { to_bitField0_ |= 0x00000001; @@ -5272,6 +5513,19 @@ public final class PTableProtos { to_bitField0_ |= 0x10000000; } result.parentNameBytes_ = parentNameBytes_; + if (((from_bitField1_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x20000000; + } + result.storageScheme_ = storageScheme_; + if (encodedCQCountersBuilder_ == null) { + if (((bitField1_ & 0x00000002) == 0x00000002)) { + encodedCQCounters_ = java.util.Collections.unmodifiableList(encodedCQCounters_); + bitField1_ = (bitField1_ & ~0x00000002); + } + result.encodedCQCounters_ = encodedCQCounters_; + } else { + result.encodedCQCounters_ = encodedCQCountersBuilder_.build(); + } result.bitField0_ = to_bitField0_; onBuilt(); return result; @@ -5441,6 +5695,35 @@ public final class PTableProtos { if (other.hasParentNameBytes()) { setParentNameBytes(other.getParentNameBytes()); } + if (other.hasStorageScheme()) { + setStorageScheme(other.getStorageScheme()); + } + if (encodedCQCountersBuilder_ == null) { + if (!other.encodedCQCounters_.isEmpty()) { + if (encodedCQCounters_.isEmpty()) { + encodedCQCounters_ = other.encodedCQCounters_; + bitField1_ = (bitField1_ & ~0x00000002); + } else { + ensureEncodedCQCountersIsMutable(); + encodedCQCounters_.addAll(other.encodedCQCounters_); + } + onChanged(); + } + } else { + if (!other.encodedCQCounters_.isEmpty()) { + if (encodedCQCountersBuilder_.isEmpty()) { + encodedCQCountersBuilder_.dispose(); + encodedCQCountersBuilder_ = null; + encodedCQCounters_ = other.encodedCQCounters_; + bitField1_ = (bitField1_ & ~0x00000002); + encodedCQCountersBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getEncodedCQCountersFieldBuilder() : null; + } else { + encodedCQCountersBuilder_.addAllMessages(other.encodedCQCounters_); + } + } + } this.mergeUnknownFields(other.getUnknownFields()); return this; } @@ -5494,6 +5777,12 @@ public final class PTableProtos { return false; } } + for (int i = 0; i < getEncodedCQCountersCount(); i++) { + if (!getEncodedCQCounters(i).isInitialized()) { + + return false; + } + } return true; } @@ -5515,6 +5804,7 @@ public final class PTableProtos { return this; } private int bitField0_; + private int bitField1_; // required bytes schemaNameBytes = 1; private com.google.protobuf.ByteString schemaNameBytes_ = com.google.protobuf.ByteString.EMPTY; @@ -7168,101 +7458,1006 @@ public final class PTableProtos { return this; } - // @@protoc_insertion_point(builder_scope:PTable) - } - - static { - defaultInstance = new PTable(true); - defaultInstance.initFields(); - } - - // @@protoc_insertion_point(class_scope:PTable) + // optional bytes storageScheme = 34; + private com.google.protobuf.ByteString storageScheme_ = com.google.protobuf.ByteString.EMPTY; + /** + * <code>optional bytes storageScheme = 34;</code> + */ + public boolean hasStorageScheme() { + return ((bitField1_ & 0x00000001) == 0x00000001); + } + /** + * <code>optional bytes storageScheme = 34;</code> + */ + public com.google.protobuf.ByteString getStorageScheme() { + return storageScheme_; + } + /** + * <code>optional bytes storageScheme = 34;</code> + */ + public Builder setStorageScheme(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); } + bitField1_ |= 0x00000001; + storageScheme_ = value; + onChanged(); + return this; + } + /** + * <code>optional bytes storageScheme = 34;</code> + */ + public Builder clearStorageScheme() { + bitField1_ = (bitField1_ & ~0x00000001); + storageScheme_ = getDefaultInstance().getStorageScheme(); + onChanged(); + return this; + } - private static com.google.protobuf.Descriptors.Descriptor - internal_static_PColumn_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_PColumn_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_PTableStats_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_PTableStats_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_PTable_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_PTable_fieldAccessorTable; + // repeated .EncodedCQCounter encodedCQCounters = 35; + private java.util.List<org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter> encodedCQCounters_ = + java.util.Collections.emptyList(); + private void ensureEncodedCQCountersIsMutable() { + if (!((bitField1_ & 0x00000002) == 0x00000002)) { + encodedCQCounters_ = new java.util.ArrayList<org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter>(encodedCQCounters_); + bitField1_ |= 0x00000002; + } + } - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\014PTable.proto\032\021PGuidePosts.proto\"\246\002\n\007PC" + - "olumn\022\027\n\017columnNameBytes\030\001 \002(\014\022\027\n\017family" + - "NameBytes\030\002 \001(\014\022\020\n\010dataType\030\003 \002(\t\022\021\n\tmax" + - "Length\030\004 \001(\005\022\r\n\005scale\030\005 \001(\005\022\020\n\010nullable\030" + - "\006 \002(\010\022\020\n\010position\030\007 \002(\005\022\021\n\tsortOrder\030\010 \002" + - "(\005\022\021\n\tarraySize\030\t \001(\005\022\024\n\014viewConstant\030\n " + - "\001(\014\022\026\n\016viewReferenced\030\013 \001(\010\022\022\n\nexpressio" + - "n\030\014 \001(\t\022\026\n\016isRowTimestamp\030\r \001(\010\022\021\n\tisDyn" + - "amic\030\016 \001(\010\"\232\001\n\013PTableStats\022\013\n\003key\030\001 \002(\014\022" + - "\016\n\006values\030\002 \003(\014\022\033\n\023guidePostsByteCount\030\003", - " \001(\003\022\025\n\rkeyBytesCount\030\004 \001(\003\022\027\n\017guidePost" + - "sCount\030\005 \001(\005\022!\n\013pGuidePosts\030\006 \001(\0132\014.PGui" + - "dePosts\"\217\006\n\006PTable\022\027\n\017schemaNameBytes\030\001 " + - "\002(\014\022\026\n\016tableNameBytes\030\002 \002(\014\022\036\n\ttableType" + - "\030\003 \002(\0162\013.PTableType\022\022\n\nindexState\030\004 \001(\t\022" + - "\026\n\016sequenceNumber\030\005 \002(\003\022\021\n\ttimeStamp\030\006 \002" + - "(\003\022\023\n\013pkNameBytes\030\007 \001(\014\022\021\n\tbucketNum\030\010 \002" + - "(\005\022\031\n\007columns\030\t \003(\0132\010.PColumn\022\030\n\007indexes" + - "\030\n \003(\0132\007.PTable\022\027\n\017isImmutableRows\030\013 \002(\010" + - "\022\032\n\022dataTableNameBytes\030\r \001(\014\022\031\n\021defaultF", - "amilyName\030\016 \001(\014\022\022\n\ndisableWAL\030\017 \002(\010\022\023\n\013m" + - "ultiTenant\030\020 \002(\010\022\020\n\010viewType\030\021 \001(\014\022\025\n\rvi" + - "ewStatement\030\022 \001(\014\022\025\n\rphysicalNames\030\023 \003(\014" + - "\022\020\n\010tenantId\030\024 \001(\014\022\023\n\013viewIndexId\030\025 \001(\005\022" + - "\021\n\tindexType\030\026 \001(\014\022\026\n\016statsTimeStamp\030\027 \001" + - "(\003\022\022\n\nstoreNulls\030\030 \001(\010\022\027\n\017baseColumnCoun" + - "t\030\031 \001(\005\022\036\n\026rowKeyOrderOptimizable\030\032 \001(\010\022" + - "\025\n\rtransactional\030\033 \001(\010\022\034\n\024updateCacheFre" + - "quency\030\034 \001(\003\022\035\n\025indexDisableTimestamp\030\035 " + - "\001(\003\022\031\n\021isNamespaceMapped\030\036 \001(\010\022\034\n\024autoPa", - "rititonSeqName\030\037 \001(\t\022\032\n\022isAppendOnlySche" + - "ma\030 \001(\010\022\027\n\017parentNameBytes\030! \001(\014*A\n\nPTa" + - "bleType\022\n\n\006SYSTEM\020\000\022\010\n\004USER\020\001\022\010\n\004VIEW\020\002\022" + - "\t\n\005INDEX\020\003\022\010\n\004JOIN\020\004B@\n(org.apache.phoen" + - "ix.coprocessor.generatedB\014PTableProtosH\001" + - "\210\001\001\240\001\001" - }; - com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = - new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { - public com.google.protobuf.ExtensionRegistry assignDescriptors( - com.google.protobuf.Descriptors.FileDescriptor root) { - descriptor = root; - internal_static_PColumn_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_PColumn_fieldAccessorTable = new - com.google.protobuf.GeneratedMessage.FieldAccessorTable( - internal_static_PColumn_descriptor, - new java.lang.String[] { "ColumnNameBytes", "FamilyNameBytes", "DataType", "MaxLength", "Scale", "Nullable", "Position", "SortOrder", "ArraySize", "ViewConstant", "ViewReferenced", "Expression", "IsRowTimestamp", "IsDynamic", }); - internal_static_PTableStats_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_PTableStats_fieldAccessorTable = new - com.google.protobuf.GeneratedMessage.FieldAccessorTable( - internal_static_PTableStats_descriptor, - new java.lang.String[] { "Key", "Values", "GuidePostsByteCount", "KeyBytesCount", "GuidePostsCount", "PGuidePosts", }); - internal_static_PTable_descriptor = - getDescriptor().getMessageTypes().get(2); - internal_static_PTable_fieldAccessorTable = new - com.google.protobuf.GeneratedMessage.FieldAccessorTable( - internal_static_PTable_descriptor, - new java.lang.String[] { "SchemaNameBytes", "TableNameBytes", "TableType", "IndexState", "SequenceNumber", "TimeStamp", "PkNameBytes", "BucketNum", "Columns", "Indexes", "IsImmutableRows", "DataTableNameBytes", "DefaultFamilyName", "DisableWAL", "MultiTenant", "ViewType", "ViewStatement", "PhysicalNames", "TenantId", "ViewIndexId", "IndexType", "StatsTimeStamp", "StoreNulls", "BaseColumnCount", "RowKeyOrderOptimizable", "Transactional", "UpdateCacheFrequency", "IndexDisableTimestamp", "IsNamespaceMapped", "AutoParititonSeqName", "IsAppendOnlySchema", "ParentNameBytes", }); + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder> encodedCQCountersBuilder_; + + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public java.util.List<org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter> getEncodedCQCountersList() { + if (encodedCQCountersBuilder_ == null) { + return java.util.Collections.unmodifiableList(encodedCQCounters_); + } else { + return encodedCQCountersBuilder_.getMessageList(); + } + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public int getEncodedCQCountersCount() { + if (encodedCQCountersBuilder_ == null) { + return encodedCQCounters_.size(); + } else { + return encodedCQCountersBuilder_.getCount(); + } + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter getEncodedCQCounters(int index) { + if (encodedCQCountersBuilder_ == null) { + return encodedCQCounters_.get(index); + } else { + return encodedCQCountersBuilder_.getMessage(index); + } + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public Builder setEncodedCQCounters( + int index, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter value) { + if (encodedCQCountersBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureEncodedCQCountersIsMutable(); + encodedCQCounters_.set(index, value); + onChanged(); + } else { + encodedCQCountersBuilder_.setMessage(index, value); + } + return this; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public Builder setEncodedCQCounters( + int index, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder builderForValue) { + if (encodedCQCountersBuilder_ == null) { + ensureEncodedCQCountersIsMutable(); + encodedCQCounters_.set(index, builderForValue.build()); + onChanged(); + } else { + encodedCQCountersBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public Builder addEncodedCQCounters(org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter value) { + if (encodedCQCountersBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureEncodedCQCountersIsMutable(); + encodedCQCounters_.add(value); + onChanged(); + } else { + encodedCQCountersBuilder_.addMessage(value); + } + return this; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public Builder addEncodedCQCounters( + int index, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter value) { + if (encodedCQCountersBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureEncodedCQCountersIsMutable(); + encodedCQCounters_.add(index, value); + onChanged(); + } else { + encodedCQCountersBuilder_.addMessage(index, value); + } + return this; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public Builder addEncodedCQCounters( + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder builderForValue) { + if (encodedCQCountersBuilder_ == null) { + ensureEncodedCQCountersIsMutable(); + encodedCQCounters_.add(builderForValue.build()); + onChanged(); + } else { + encodedCQCountersBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public Builder addEncodedCQCounters( + int index, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder builderForValue) { + if (encodedCQCountersBuilder_ == null) { + ensureEncodedCQCountersIsMutable(); + encodedCQCounters_.add(index, builderForValue.build()); + onChanged(); + } else { + encodedCQCountersBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public Builder addAllEncodedCQCounters( + java.lang.Iterable<? extends org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter> values) { + if (encodedCQCountersBuilder_ == null) { + ensureEncodedCQCountersIsMutable(); + super.addAll(values, encodedCQCounters_); + onChanged(); + } else { + encodedCQCountersBuilder_.addAllMessages(values); + } + return this; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public Builder clearEncodedCQCounters() { + if (encodedCQCountersBuilder_ == null) { + encodedCQCounters_ = java.util.Collections.emptyList(); + bitField1_ = (bitField1_ & ~0x00000002); + onChanged(); + } else { + encodedCQCountersBuilder_.clear(); + } + return this; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public Builder removeEncodedCQCounters(int index) { + if (encodedCQCountersBuilder_ == null) { + ensureEncodedCQCountersIsMutable(); + encodedCQCounters_.remove(index); + onChanged(); + } else { + encodedCQCountersBuilder_.remove(index); + } + return this; + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder getEncodedCQCountersBuilder( + int index) { + return getEncodedCQCountersFieldBuilder().getBuilder(index); + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder getEncodedCQCountersOrBuilder( + int index) { + if (encodedCQCountersBuilder_ == null) { + return encodedCQCounters_.get(index); } else { + return encodedCQCountersBuilder_.getMessageOrBuilder(index); + } + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public java.util.List<? extends org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder> + getEncodedCQCountersOrBuilderList() { + if (encodedCQCountersBuilder_ != null) { + return encodedCQCountersBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(encodedCQCounters_); + } + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder addEncodedCQCountersBuilder() { + return getEncodedCQCountersFieldBuilder().addBuilder( + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.getDefaultInstance()); + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder addEncodedCQCountersBuilder( + int index) { + return getEncodedCQCountersFieldBuilder().addBuilder( + index, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.getDefaultInstance()); + } + /** + * <code>repeated .EncodedCQCounter encodedCQCounters = 35;</code> + */ + public java.util.List<org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder> + getEncodedCQCountersBuilderList() { + return getEncodedCQCountersFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder> + getEncodedCQCountersFieldBuilder() { + if (encodedCQCountersBuilder_ == null) { + encodedCQCountersBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder>( + encodedCQCounters_, + ((bitField1_ & 0x00000002) == 0x00000002), + getParentForChildren(), + isClean()); + encodedCQCounters_ = null; + } + return encodedCQCountersBuilder_; + } + + // @@protoc_insertion_point(builder_scope:PTable) + } + + static { + defaultInstance = new PTable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:PTable) + } + + public interface EncodedCQCounterOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string colFamily = 1; + /** + * <code>required string colFamily = 1;</code> + */ + boolean hasColFamily(); + /** + * <code>required string colFamily = 1;</code> + */ + java.lang.String getColFamily(); + /** + * <code>required string colFamily = 1;</code> + */ + com.google.protobuf.ByteString + getColFamilyBytes(); + + // required int32 counter = 2; + /** + * <code>required int32 counter = 2;</code> + */ + boolean hasCounter(); + /** + * <code>required int32 counter = 2;</code> + */ + int getCounter(); + } + /** + * Protobuf type {@code EncodedCQCounter} + */ + public static final class EncodedCQCounter extends + com.google.protobuf.GeneratedMessage + implements EncodedCQCounterOrBuilder { + // Use EncodedCQCounter.newBuilder() to construct. + private EncodedCQCounter(com.google.protobuf.GeneratedMessage.Builder<?> builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private EncodedCQCounter(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final EncodedCQCounter defaultInstance; + public static EncodedCQCounter getDefaultInstance() { + return defaultInstance; + } + + public EncodedCQCounter getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private EncodedCQCounter( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + colFamily_ = input.readBytes(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + counter_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.phoenix.coprocessor.generated.PTableProtos.internal_static_EncodedCQCounter_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.phoenix.coprocessor.generated.PTableProtos.internal_static_EncodedCQCounter_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.class, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder.class); + } + + public static com.google.protobuf.Parser<EncodedCQCounter> PARSER = + new com.google.protobuf.AbstractParser<EncodedCQCounter>() { + public EncodedCQCounter parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new EncodedCQCounter(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser<EncodedCQCounter> getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string colFamily = 1; + public static final int COLFAMILY_FIELD_NUMBER = 1; + private java.lang.Object colFamily_; + /** + * <code>required string colFamily = 1;</code> + */ + public boolean hasColFamily() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * <code>required string colFamily = 1;</code> + */ + public java.lang.String getColFamily() { + java.lang.Object ref = colFamily_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + colFamily_ = s; + } + return s; + } + } + /** + * <code>required string colFamily = 1;</code> + */ + public com.google.protobuf.ByteString + getColFamilyBytes() { + java.lang.Object ref = colFamily_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + colFamily_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required int32 counter = 2; + public static final int COUNTER_FIELD_NUMBER = 2; + private int counter_; + /** + * <code>required int32 counter = 2;</code> + */ + public boolean hasCounter() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * <code>required int32 counter = 2;</code> + */ + public int getCounter() { + return counter_; + } + + private void initFields() { + colFamily_ = ""; + counter_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasColFamily()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasCounter()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getColFamilyBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, counter_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getColFamilyBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, counter_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter)) { + return super.equals(obj); + } + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter other = (org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter) obj; + + boolean result = true; + result = result && (hasColFamily() == other.hasColFamily()); + if (hasColFamily()) { + result = result && getColFamily() + .equals(other.getColFamily()); + } + result = result && (hasCounter() == other.hasCounter()); + if (hasCounter()) { + result = result && (getCounter() + == other.getCounter()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + private int memoizedHashCode = 0; + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasColFamily()) { + hash = (37 * hash) + COLFAMILY_FIELD_NUMBER; + hash = (53 * hash) + getColFamily().hashCode(); + } + if (hasCounter()) { + hash = (37 * hash) + COUNTER_FIELD_NUMBER; + hash = (53 * hash) + getCounter(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code EncodedCQCounter} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder<Builder> + implements org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounterOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.phoenix.coprocessor.generated.PTableProtos.internal_static_EncodedCQCounter_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.phoenix.coprocessor.generated.PTableProtos.internal_static_EncodedCQCounter_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.class, org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.Builder.class); + } + + // Construct using org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + colFamily_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + counter_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.apache.phoenix.coprocessor.generated.PTableProtos.internal_static_EncodedCQCounter_descriptor; + } + + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter getDefaultInstanceForType() { + return org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.getDefaultInstance(); + } + + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter build() { + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter buildPartial() { + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter result = new org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.colFamily_ = colFamily_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.counter_ = counter_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter) { + return mergeFrom((org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter other) { + if (other == org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter.getDefaultInstance()) return this; + if (other.hasColFamily()) { + bitField0_ |= 0x00000001; + colFamily_ = other.colFamily_; + onChanged(); + } + if (other.hasCounter()) { + setCounter(other.getCounter()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasColFamily()) { + + return false; + } + if (!hasCounter()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.apache.phoenix.coprocessor.generated.PTableProtos.EncodedCQCounter) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string colFamily = 1; + private java.lang.Object colFamily_ = ""; + /** + * <code>required string colFamily = 1;</code> + */ + public boolean hasColFamily() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * <code>required string colFamily = 1;</code> + */ + public java.lang.String getColFamily() { + java.lang.Object ref = colFamily_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + colFamily_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * <code>required string colFamily = 1;</code> + */ + public com.google.protobuf.ByteString + getColFamilyBytes() { + java.lang.Object ref = colFamily_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + colFamily_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * <code>required string colFamily = 1;</code> + */ + public Builder setColFamily( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + colFamily_ = value; + onChanged(); + return this; + } + /** + * <code>required string colFamily = 1;</code> + */ + public Builder clearColFamily() { + bitField0_ = (bitField0_ & ~0x00000001); + colFamily_ = getDefaultInstance().getColFamily(); + onChanged(); + return this; + } + /** + * <code>required string colFamily = 1;</code> + */ + public Builder setColFamilyBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + colFamily_ = value; + onChanged(); + return this; + } + + // required int32 counter = 2; + private int counter_ ; + /** + * <code>required int32 counter = 2;</code> + */ + public boolean hasCounter() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * <code>required int32 counter = 2;</code> + */ + public int getCounter() { + return counter_; + } + /** + * <code>required int32 counter = 2;</code> + */ + public Builder setCounter(int value) { + bitField0_ |= 0x00000002; + counter_ = value; + onChanged(); + return this; + } + /** + * <code>required int32 counter = 2;</code> + */ + public Builder clearCounter() { + bitField0_ = (bitField0_ & ~0x00000002); + counter_ = 0; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:EncodedCQCounter) + } + + static { + defaultInstance = new EncodedCQCounter(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:EncodedCQCounter) + } + + private static com.google.protobuf.Descriptors.Descriptor + internal_static_PColumn_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_PColumn_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_PTableStats_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_PTableStats_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_PTable_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_PTable_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_EncodedCQCounter_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_EncodedCQCounter_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\014PTable.proto\032\021PGuidePosts.proto\"\277\002\n\007PC" + + "olumn\022\027\n\017columnNameBytes\030\001 \002(\014\022\027\n\017family" + + "NameBytes\030\002 \001(\014\022\020\n\010dataType\030\003 \002(\t\022\021\n\tmax" + + "Length\030\004 \001(\005\022\r\n\005scale\030\005 \001(\005\022\020\n\010nullable\030" + + "\006 \002(\010\022\020\n\010position\030\007 \002(\005\022\021\n\tsortOrder\030\010 \002" + + "(\005\022\021\n\tarraySize\030\t \001(\005\022\024\n\014viewConstant\030\n " + + "\001(\014\022\026\n\016viewReferenced\030\013 \001(\010\022\022\n\nexpressio" + + "n\030\014 \001(\t\022\026\n\016isRowTimestamp\030\r \001(\010\022\021\n\tisDyn" + + "amic\030\016 \001(\010\022\027\n\017columnQualifier\030\017 \001(\005\"\232\001\n\013" + + "PTableStats\022\013\n\003key\030\001 \002(\014\022\016\n\006values\030\002 \003(\014", + "\022\033\n\023guidePostsByteCount\030\003 \001(\003\022\025\n\rkeyByte" + + "sCount\030\004 \001(\003\022\027\n\017guidePostsCount\030\005 \001(\005\022!\n" + + "\013pGuidePosts\030\006 \001(\0132\014.PGuidePosts\"\324\006\n\006PTa" + + "ble\022\027\n\017schemaNameBytes\030\001 \002(\014\022\026\n\016tableNam" + + "eBytes\030\002 \002(\014\022\036\n\ttableType\030\003 \002(\0162\013.PTable" + + "Type\022\022\n\nindexState\030\004 \001(\t\022\026\n\016sequenceNumb" + + "er\030\005 \002(\003\022\021\n\ttimeStamp\030\006 \002(\003\022\023\n\013pkNameByt" + + "es\030\007 \001(\014\022\021\n\tbucketNum\030\010 \002(\005\022\031\n\007columns\030\t" + + " \003(\0132\010.PColumn\022\030\n\007indexes\030\n \003(\0132\007.PTable" + + "\022\027\n\017isImmutableRows\030\013 \002(\010\022\032\n\022dataTableNa", + "meBytes\030\r \001(\014\022\031\n\021defaultFamilyName\030\016 \001(\014" + + "\022\022\n\ndisableWAL\030\017 \002(\010\022\023\n\013multiTenant\030\020 \002(" + + "\010\022\020\n\010viewType\030\021 \001(\014\022\025\n\rviewStatement\030\022 \001" + + "(\014\022\025\n\rphysicalNames\030\023 \003(\014\022\020\n\010tenantId\030\024 " + + "\001(\014\022\023\n\013viewIndexId\030\025 \001(\005\022\021\n\tindexType\030\026 " + + "\001(\014\022\026\n\016statsTimeStamp\030\027 \001(\003\022\022\n\nstoreNull" + + "s\030\030 \001(\010\022\027\n\017baseColumnCount\030\031 \001(\005\022\036\n\026rowK" + + "eyOrderOptimizable\030\032 \001(\010\022\025\n\rtransactiona" + + "l\030\033 \001(\010\022\034\n\024updateCacheFrequency\030\034 \001(\003\022\035\n" + + "\025indexDisableTimestamp\030\035 \001(\003\022\031\n\021isNamesp", + "aceMapped\030\036 \001(\010\022\034\n\024autoParititonSeqName\030" + + "\037 \001(\t\022\032\n\022isAppendOnlySchema\030 \001(\010\022\027\n\017par" + + "entNameBytes\030! \001(\014\022\025\n\rstorageScheme\030\" \001(" + + "\014\022,\n\021encodedCQCounters\030# \003(\0132\021.EncodedCQ" + + "Counter\"6\n\020EncodedCQCounter\022\021\n\tcolFamily" + + "\030\001 \002(\t\022\017\n\007counter\030\002 \002(\005*A\n\nPTableType\022\n\n" + + "\006SYSTEM\020\000\022\010\n\004USER\020\001\022\010\n\004VIEW\020\002\022\t\n\005INDEX\020\003" + + "\022\010\n\004JOIN\020\004B@\n(org.apache.phoenix.coproce" + + "ssor.generatedB\014PTableProtosH\001\210\001\001\240\001\001" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + internal_static_PColumn_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_PColumn_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_PColumn_descriptor, + new java.lang.String[] { "ColumnNameBytes", "FamilyNameBytes", "DataType", "MaxLength", "Scale", "Nullable", "Position", "SortOrder", "ArraySize", "ViewConstant", "ViewReferenced", "Expression", "IsRowTimestamp", "IsDynamic", "ColumnQualifier", }); + internal_static_PTableStats_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_PTableStats_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_PTableStats_descriptor, + new java.lang.String[] { "Key", "Values", "GuidePostsByteCount", "KeyBytesCount", "GuidePostsCount", "PGuidePosts", }); + internal_static_PTable_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_PTable_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_PTable_descriptor, + new java.lang.String[] { "SchemaNameBytes", "TableNameBytes", "TableType", "IndexState", "SequenceNumber", "TimeStamp", "PkNameBytes", "BucketNum", "Columns", "Indexes", "IsImmutableRows", "DataTableNameBytes", "DefaultFamilyName", "DisableWAL", "MultiTenant", "ViewType", "ViewStatement", "PhysicalNames", "TenantId", "ViewIndexId", "IndexType", "StatsTimeStamp", "StoreNulls", "BaseColumnCount", "RowKeyOrderOptimizable", "Transactional", "UpdateCacheFrequency", "IndexDisableTimestamp", "IsNamespaceMapped", "AutoParititonSeqName", "IsAppendOnlySchema", "ParentNameBytes", "StorageScheme", "EncodedCQCounters", }); + internal_static_EncodedCQCounter_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_EncodedCQCounter_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_EncodedCQCounter_descriptor, + new java.lang.String[] { "ColFamily", "Counter", }); return null; } };
http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/execute/BaseQueryPlan.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/execute/BaseQueryPlan.java b/phoenix-core/src/main/java/org/apache/phoenix/execute/BaseQueryPlan.java index 352b533..fb5af32 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/execute/BaseQueryPlan.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/execute/BaseQueryPlan.java @@ -64,11 +64,13 @@ import org.apache.phoenix.schema.PColumn; import org.apache.phoenix.schema.PName; import org.apache.phoenix.schema.PTable; import org.apache.phoenix.schema.PTable.IndexType; +import org.apache.phoenix.schema.PTable.StorageScheme; import org.apache.phoenix.schema.PTableType; import org.apache.phoenix.schema.TableRef; import org.apache.phoenix.trace.TracingIterator; import org.apache.phoenix.trace.util.Tracing; import org.apache.phoenix.util.ByteUtil; +import org.apache.phoenix.util.EncodedColumnsUtil; import org.apache.phoenix.util.IndexUtil; import org.apache.phoenix.util.LogUtil; import org.apache.phoenix.util.SQLCloseable; @@ -307,10 +309,6 @@ public abstract class BaseQueryPlan implements QueryPlan { // project is not present in the index then we need to skip this plan. if (!dataColumns.isEmpty()) { // Set data columns to be join back from data table. - serializeDataTableColumnsToJoin(scan, dataColumns); - KeyValueSchema schema = ProjectedColumnExpression.buildSchema(dataColumns); - // Set key value schema of the data columns. - serializeSchemaIntoScan(scan, schema); PTable parentTable = context.getCurrentTable().getTable(); String parentSchemaName = parentTable.getParentSchemaName().getString(); String parentTableName = parentTable.getParentTableName().getString(); @@ -321,6 +319,12 @@ public abstract class BaseQueryPlan implements QueryPlan { FACTORY.namedTable(null, TableName.create(parentSchemaName, parentTableName)), context.getConnection()).resolveTable(parentSchemaName, parentTableName); PTable dataTable = dataTableRef.getTable(); + // Set data columns to be join back from data table. + serializeDataTableColumnsToJoin(scan, dataColumns, dataTable); + KeyValueSchema schema = ProjectedColumnExpression.buildSchema(dataColumns); + // Set key value schema of the data columns. + serializeSchemaIntoScan(scan, schema); + // Set index maintainer of the local index. serializeIndexMaintainerIntoScan(scan, dataTable); // Set view constants if exists. @@ -423,14 +427,21 @@ public abstract class BaseQueryPlan implements QueryPlan { } } - private void serializeDataTableColumnsToJoin(Scan scan, Set<PColumn> dataColumns) { + private void serializeDataTableColumnsToJoin(Scan scan, Set<PColumn> dataColumns, PTable dataTable) { ByteArrayOutputStream stream = new ByteArrayOutputStream(); try { DataOutputStream output = new DataOutputStream(stream); + boolean storeColsInSingleCell = dataTable.getStorageScheme() == StorageScheme.COLUMNS_STORED_IN_SINGLE_CELL; + if (storeColsInSingleCell) { + // if storeColsInSingleCell is true all columns of a given column family are stored in a single cell + scan.setAttribute(BaseScannerRegionObserver.COLUMNS_STORED_IN_SINGLE_CELL, QueryConstants.EMPTY_COLUMN_VALUE_BYTES); + } WritableUtils.writeVInt(output, dataColumns.size()); for (PColumn column : dataColumns) { - Bytes.writeByteArray(output, column.getFamilyName().getBytes()); - Bytes.writeByteArray(output, column.getName().getBytes()); + byte[] cf = column.getFamilyName().getBytes(); + byte[] cq = EncodedColumnsUtil.getColumnQualifier(column, dataTable); + Bytes.writeByteArray(output, cf); + Bytes.writeByteArray(output, cq); } scan.setAttribute(BaseScannerRegionObserver.DATA_TABLE_COLUMNS_TO_JOIN, stream.toByteArray()); } catch (IOException e) { http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/execute/MutationState.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/execute/MutationState.java b/phoenix-core/src/main/java/org/apache/phoenix/execute/MutationState.java index cb66968..a030150 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/execute/MutationState.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/execute/MutationState.java @@ -585,7 +585,7 @@ public class MutationState implements SQLCloseable { List<Mutation> indexMutations; try { indexMutations = - IndexUtil.generateIndexData(table, index, mutationsPertainingToIndex, + IndexUtil.generateIndexData(table, index, values, mutationsPertainingToIndex, connection.getKeyValueBuilder(), connection); // we may also have to include delete mutations for immutable tables if we are not processing all the tables in the mutations map if (!sendAll) { @@ -619,6 +619,7 @@ public class MutationState implements SQLCloseable { Iterator<Map.Entry<ImmutableBytesPtr, RowMutationState>> iterator = values.entrySet().iterator(); long timestampToUse = timestamp; + Map<ImmutableBytesPtr, RowMutationState> modifiedValues = Maps.newHashMap(); while (iterator.hasNext()) { Map.Entry<ImmutableBytesPtr, RowMutationState> rowEntry = iterator.next(); byte[] onDupKeyBytes = rowEntry.getValue().getOnDupKeyBytes(); @@ -628,6 +629,10 @@ public class MutationState implements SQLCloseable { if (tableWithRowTimestampCol) { RowTimestampColInfo rowTsColInfo = state.getRowTimestampColInfo(); if (rowTsColInfo.useServerTimestamp()) { + // since we are about to modify the byte[] stored in key (which changes its hashcode) + // we need to remove the entry from the values map and add a new entry with the modified byte[] + modifiedValues.put(key, state); + iterator.remove(); // regenerate the key with this timestamp. key = getNewRowKeyWithRowTimestamp(key, timestampToUse, table); } else { @@ -668,6 +673,7 @@ public class MutationState implements SQLCloseable { if (mutationsPertainingToIndex != null) mutationsPertainingToIndex .addAll(rowMutationsPertainingToIndex); } + values.putAll(modifiedValues); } /** @@ -806,7 +812,7 @@ public class MutationState implements SQLCloseable { } for (PColumn column : columns) { if (column != null) { - resolvedTable.getColumnFamily(column.getFamilyName().getString()).getColumn(column.getName().getString()); + resolvedTable.getColumnFamily(column.getFamilyName().getString()).getPColumnForColumnName(column.getName().getString()); } } } @@ -1480,8 +1486,8 @@ public class MutationState implements SQLCloseable { byte[] getOnDupKeyBytes() { return onDupKeyBytes; } - - Map<PColumn, byte[]> getColumnValues() { + + public Map<PColumn, byte[]> getColumnValues() { return columnValues; } http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/execute/TupleProjector.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/execute/TupleProjector.java b/phoenix-core/src/main/java/org/apache/phoenix/execute/TupleProjector.java index 592b68e..127af96 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/execute/TupleProjector.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/execute/TupleProjector.java @@ -17,6 +17,9 @@ */ package org.apache.phoenix.execute; +import static org.apache.phoenix.query.QueryConstants.VALUE_COLUMN_FAMILY; +import static org.apache.phoenix.query.QueryConstants.VALUE_COLUMN_QUALIFIER; + import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; @@ -51,9 +54,6 @@ import org.apache.phoenix.util.SchemaUtil; import com.google.common.base.Preconditions; public class TupleProjector { - public static final byte[] VALUE_COLUMN_FAMILY = Bytes.toBytes("_v"); - public static final byte[] VALUE_COLUMN_QUALIFIER = new byte[0]; - private static final String SCAN_PROJECTOR = "scanProjector"; private final KeyValueSchema schema; http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayColumnExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayColumnExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayColumnExpression.java new file mode 100644 index 0000000..f4616da --- /dev/null +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayColumnExpression.java @@ -0,0 +1,142 @@ +/* + * 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.phoenix.expression; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.hadoop.hbase.io.ImmutableBytesWritable; +import org.apache.hadoop.io.WritableUtils; +import org.apache.phoenix.compile.CreateTableCompiler.ViewWhereExpressionVisitor; +import org.apache.phoenix.expression.visitor.ExpressionVisitor; +import org.apache.phoenix.schema.PColumn; +import org.apache.phoenix.schema.PDatum; +import org.apache.phoenix.schema.SortOrder; +import org.apache.phoenix.schema.tuple.Tuple; +import org.apache.phoenix.schema.types.PArrayDataType; +import org.apache.phoenix.schema.types.PDataType; +import org.apache.phoenix.schema.types.PVarbinary; +import org.apache.phoenix.util.EncodedColumnsUtil; +import org.apache.phoenix.util.SchemaUtil; + +/** + * + * Class to access a column that is stored in a KeyValue that contains all + * columns for a given column family (stored in an array). + * + */ +public class ArrayColumnExpression extends KeyValueColumnExpression { + + private int encodedCQ; + private String displayName; + + public ArrayColumnExpression() { + } + + public ArrayColumnExpression(PDatum column, byte[] cf, int encodedCQ) { + super(column, cf, cf); + this.encodedCQ = encodedCQ; + } + + public ArrayColumnExpression(PColumn column, String displayName, boolean encodedColumnName) { + super(column, column.getFamilyName().getBytes(), column.getFamilyName().getBytes()); + this.displayName = SchemaUtil.getColumnDisplayName(column.getFamilyName().getString(), column.getName().getString()); + this.encodedCQ = column.getEncodedColumnQualifier(); + } + + @Override + public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { + if (!super.evaluate(tuple, ptr)) { + return false; + } else if (ptr.getLength() == 0) { + return true; + } + + // Given a ptr to the entire array, set ptr to point to a particular element within that array + // given the type of an array element (see comments in PDataTypeForArray) + PArrayDataType.positionAtArrayElement(ptr, encodedCQ, PVarbinary.INSTANCE, null); + return true; + } + + @Override + public void readFields(DataInput input) throws IOException { + super.readFields(input); + encodedCQ = WritableUtils.readVInt(input); + } + + @Override + public void write(DataOutput output) throws IOException { + super.write(output); + WritableUtils.writeVInt(output, encodedCQ); + } + + public KeyValueColumnExpression getKeyValueExpression() { + final boolean isNullable = isNullable(); + final SortOrder sortOrder = getSortOrder(); + final Integer scale = getScale(); + final Integer maxLength = getMaxLength(); + final PDataType datatype = getDataType(); + return new KeyValueColumnExpression(new PDatum() { + + @Override + public boolean isNullable() { + return isNullable; + } + + @Override + public SortOrder getSortOrder() { + return sortOrder; + } + + @Override + public Integer getScale() { + return scale; + } + + @Override + public Integer getMaxLength() { + return maxLength; + } + + @Override + public PDataType getDataType() { + return datatype; + } + }, getColumnFamily(), getEncodedColumnQualifier()); + } + + @Override + public String toString() { + return displayName; + } + + public byte[] getEncodedColumnQualifier() { + return EncodedColumnsUtil.getEncodedColumnQualifier(encodedCQ); + } + + @Override + public <T> T accept(ExpressionVisitor<T> visitor) { + //FIXME: this is ugly but can't think of a good solution. + if (visitor instanceof ViewWhereExpressionVisitor) { + return visitor.visit(this); + } else { + return super.accept(visitor); + } + } +} http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayConstructorExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayConstructorExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayConstructorExpression.java index c2f4dd2..783e962 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayConstructorExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayConstructorExpression.java @@ -117,7 +117,7 @@ public class ArrayConstructorExpression extends BaseCompoundExpression { offsetPos[i] = byteStream.size(); oStream.write(ptr.get(), ptr.getOffset(), ptr.getLength()); oStream.write(PArrayDataType.getSeparatorByte(rowKeyOrderOptimizable, getSortOrder())); - nNulls=0; + nNulls = 0; } } else { // No nulls for fixed length oStream.write(ptr.get(), ptr.getOffset(), ptr.getLength()); http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/expression/ExpressionType.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/ExpressionType.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/ExpressionType.java index 658605e..006777b 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/ExpressionType.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/ExpressionType.java @@ -178,9 +178,8 @@ public enum ExpressionType { CeilYearExpression(CeilYearExpression.class), DayOfWeekFunction(DayOfWeekFunction.class), DayOfYearFunction(DayOfYearFunction.class), - DefaultValueExpression(DefaultValueExpression.class); - - + DefaultValueExpression(DefaultValueExpression.class), + ArrayColumnExpression(ArrayColumnExpression.class); ExpressionType(Class<? extends Expression> clazz) { this.clazz = clazz; } http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/expression/KeyValueColumnExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/KeyValueColumnExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/KeyValueColumnExpression.java index 4b5fdbb..6170418 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/KeyValueColumnExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/KeyValueColumnExpression.java @@ -28,6 +28,7 @@ import org.apache.phoenix.expression.visitor.ExpressionVisitor; import org.apache.phoenix.schema.PColumn; import org.apache.phoenix.schema.PDatum; import org.apache.phoenix.schema.tuple.Tuple; +import org.apache.phoenix.util.EncodedColumnsUtil; import org.apache.phoenix.util.SchemaUtil; @@ -41,13 +42,13 @@ import org.apache.phoenix.util.SchemaUtil; public class KeyValueColumnExpression extends ColumnExpression { private byte[] cf; private byte[] cq; - private String displayName; // client-side only + private String displayName; // client-side only. TODO: samarth see what can you do for encoded column names. public KeyValueColumnExpression() { } - public KeyValueColumnExpression(PColumn column) { - this(column, null); + public KeyValueColumnExpression(PColumn column, boolean encodedColumnName) { + this(column, null, encodedColumnName); } public KeyValueColumnExpression(PDatum column, byte[] cf, byte[] cq) { @@ -56,18 +57,18 @@ public class KeyValueColumnExpression extends ColumnExpression { this.cq = cq; } - public KeyValueColumnExpression(PColumn column, String displayName) { + public KeyValueColumnExpression(PColumn column, String displayName, boolean encodedColumnName) { super(column); this.cf = column.getFamilyName().getBytes(); - this.cq = column.getName().getBytes(); + this.cq = EncodedColumnsUtil.getColumnQualifier(column, encodedColumnName); this.displayName = displayName; } public byte[] getColumnFamily() { return cf; } - - public byte[] getColumnName() { + + public byte[] getColumnQualifier() { return cq; } @@ -120,7 +121,7 @@ public class KeyValueColumnExpression extends ColumnExpression { } @Override - public final <T> T accept(ExpressionVisitor<T> visitor) { + public <T> T accept(ExpressionVisitor<T> visitor) { return visitor.visit(this); } } http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java index 90882a2..f20d7e2 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java @@ -23,6 +23,7 @@ import java.io.IOException; import java.sql.SQLException; import org.apache.hadoop.hbase.io.ImmutableBytesWritable; +import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.io.WritableUtils; import org.apache.phoenix.expression.visitor.ExpressionVisitor; import org.apache.phoenix.schema.IllegalDataException; @@ -214,6 +215,11 @@ public class LiteralExpression extends BaseTerminalExpression { public LiteralExpression() { } + + public LiteralExpression(byte[] byteValue) { + this.byteValue = byteValue!=null ? byteValue : ByteUtil.EMPTY_BYTE_ARRAY; + this.determinism = Determinism.ALWAYS; + } private LiteralExpression(PDataType type, Determinism determinism) { this(null, type, ByteUtil.EMPTY_BYTE_ARRAY, determinism); @@ -242,7 +248,10 @@ public class LiteralExpression extends BaseTerminalExpression { @Override public String toString() { - if (value == null) { + if (value == null && byteValue!=null) { + return Bytes.toStringBinary(byteValue); + } + else if (value == null) { return "null"; } // TODO: move into PDataType? http://git-wip-us.apache.org/repos/asf/phoenix/blob/670b53a9/phoenix-core/src/main/java/org/apache/phoenix/expression/ProjectedColumnExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/ProjectedColumnExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/ProjectedColumnExpression.java index 3a38dee..2744f35 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/ProjectedColumnExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/ProjectedColumnExpression.java @@ -154,6 +154,7 @@ public class ProjectedColumnExpression extends ColumnExpression { return Determinism.PER_INVOCATION; } + @Override public ProjectedColumnExpression clone() { return new ProjectedColumnExpression(this.column, this.columns, this.position, this.displayName); }