http://git-wip-us.apache.org/repos/asf/calcite/blob/97df1acb/avatica/src/main/java/org/apache/calcite/avatica/proto/Common.java ---------------------------------------------------------------------- diff --git a/avatica/src/main/java/org/apache/calcite/avatica/proto/Common.java b/avatica/src/main/java/org/apache/calcite/avatica/proto/Common.java index b693b77..1dbe093 100644 --- a/avatica/src/main/java/org/apache/calcite/avatica/proto/Common.java +++ b/avatica/src/main/java/org/apache/calcite/avatica/proto/Common.java @@ -669,6 +669,410 @@ package org.apache.calcite.avatica.proto; // @@protoc_insertion_point(enum_scope:Severity) } + /** + * Protobuf enum {@code MetaDataOperation} + * + * <pre> + * Enumeration corresponding to DatabaseMetaData operations + * </pre> + */ + public enum MetaDataOperation + implements com.google.protobuf.ProtocolMessageEnum { + /** + * <code>GET_ATTRIBUTES = 0;</code> + */ + GET_ATTRIBUTES(0, 0), + /** + * <code>GET_BEST_ROW_IDENTIFIER = 1;</code> + */ + GET_BEST_ROW_IDENTIFIER(1, 1), + /** + * <code>GET_CATALOGS = 2;</code> + */ + GET_CATALOGS(2, 2), + /** + * <code>GET_CLIENT_INFO_PROPERTIES = 3;</code> + */ + GET_CLIENT_INFO_PROPERTIES(3, 3), + /** + * <code>GET_COLUMN_PRIVILEGES = 4;</code> + */ + GET_COLUMN_PRIVILEGES(4, 4), + /** + * <code>GET_COLUMNS = 5;</code> + */ + GET_COLUMNS(5, 5), + /** + * <code>GET_CROSS_REFERENCE = 6;</code> + */ + GET_CROSS_REFERENCE(6, 6), + /** + * <code>GET_EXPORTED_KEYS = 7;</code> + */ + GET_EXPORTED_KEYS(7, 7), + /** + * <code>GET_FUNCTION_COLUMNS = 8;</code> + */ + GET_FUNCTION_COLUMNS(8, 8), + /** + * <code>GET_FUNCTIONS = 9;</code> + */ + GET_FUNCTIONS(9, 9), + /** + * <code>GET_IMPORTED_KEYS = 10;</code> + */ + GET_IMPORTED_KEYS(10, 10), + /** + * <code>GET_INDEX_INFO = 11;</code> + */ + GET_INDEX_INFO(11, 11), + /** + * <code>GET_PRIMARY_KEYS = 12;</code> + */ + GET_PRIMARY_KEYS(12, 12), + /** + * <code>GET_PROCEDURE_COLUMNS = 13;</code> + */ + GET_PROCEDURE_COLUMNS(13, 13), + /** + * <code>GET_PROCEDURES = 14;</code> + */ + GET_PROCEDURES(14, 14), + /** + * <code>GET_PSEUDO_COLUMNS = 15;</code> + */ + GET_PSEUDO_COLUMNS(15, 15), + /** + * <code>GET_SCHEMAS = 16;</code> + */ + GET_SCHEMAS(16, 16), + /** + * <code>GET_SCHEMAS_WITH_ARGS = 17;</code> + */ + GET_SCHEMAS_WITH_ARGS(17, 17), + /** + * <code>GET_SUPER_TABLES = 18;</code> + */ + GET_SUPER_TABLES(18, 18), + /** + * <code>GET_SUPER_TYPES = 19;</code> + */ + GET_SUPER_TYPES(19, 19), + /** + * <code>GET_TABLE_PRIVILEGES = 20;</code> + */ + GET_TABLE_PRIVILEGES(20, 20), + /** + * <code>GET_TABLES = 21;</code> + */ + GET_TABLES(21, 21), + /** + * <code>GET_TABLE_TYPES = 22;</code> + */ + GET_TABLE_TYPES(22, 22), + /** + * <code>GET_TYPE_INFO = 23;</code> + */ + GET_TYPE_INFO(23, 23), + /** + * <code>GET_UDTS = 24;</code> + */ + GET_UDTS(24, 24), + /** + * <code>GET_VERSION_COLUMNS = 25;</code> + */ + GET_VERSION_COLUMNS(25, 25), + UNRECOGNIZED(-1, -1), + ; + + /** + * <code>GET_ATTRIBUTES = 0;</code> + */ + public static final int GET_ATTRIBUTES_VALUE = 0; + /** + * <code>GET_BEST_ROW_IDENTIFIER = 1;</code> + */ + public static final int GET_BEST_ROW_IDENTIFIER_VALUE = 1; + /** + * <code>GET_CATALOGS = 2;</code> + */ + public static final int GET_CATALOGS_VALUE = 2; + /** + * <code>GET_CLIENT_INFO_PROPERTIES = 3;</code> + */ + public static final int GET_CLIENT_INFO_PROPERTIES_VALUE = 3; + /** + * <code>GET_COLUMN_PRIVILEGES = 4;</code> + */ + public static final int GET_COLUMN_PRIVILEGES_VALUE = 4; + /** + * <code>GET_COLUMNS = 5;</code> + */ + public static final int GET_COLUMNS_VALUE = 5; + /** + * <code>GET_CROSS_REFERENCE = 6;</code> + */ + public static final int GET_CROSS_REFERENCE_VALUE = 6; + /** + * <code>GET_EXPORTED_KEYS = 7;</code> + */ + public static final int GET_EXPORTED_KEYS_VALUE = 7; + /** + * <code>GET_FUNCTION_COLUMNS = 8;</code> + */ + public static final int GET_FUNCTION_COLUMNS_VALUE = 8; + /** + * <code>GET_FUNCTIONS = 9;</code> + */ + public static final int GET_FUNCTIONS_VALUE = 9; + /** + * <code>GET_IMPORTED_KEYS = 10;</code> + */ + public static final int GET_IMPORTED_KEYS_VALUE = 10; + /** + * <code>GET_INDEX_INFO = 11;</code> + */ + public static final int GET_INDEX_INFO_VALUE = 11; + /** + * <code>GET_PRIMARY_KEYS = 12;</code> + */ + public static final int GET_PRIMARY_KEYS_VALUE = 12; + /** + * <code>GET_PROCEDURE_COLUMNS = 13;</code> + */ + public static final int GET_PROCEDURE_COLUMNS_VALUE = 13; + /** + * <code>GET_PROCEDURES = 14;</code> + */ + public static final int GET_PROCEDURES_VALUE = 14; + /** + * <code>GET_PSEUDO_COLUMNS = 15;</code> + */ + public static final int GET_PSEUDO_COLUMNS_VALUE = 15; + /** + * <code>GET_SCHEMAS = 16;</code> + */ + public static final int GET_SCHEMAS_VALUE = 16; + /** + * <code>GET_SCHEMAS_WITH_ARGS = 17;</code> + */ + public static final int GET_SCHEMAS_WITH_ARGS_VALUE = 17; + /** + * <code>GET_SUPER_TABLES = 18;</code> + */ + public static final int GET_SUPER_TABLES_VALUE = 18; + /** + * <code>GET_SUPER_TYPES = 19;</code> + */ + public static final int GET_SUPER_TYPES_VALUE = 19; + /** + * <code>GET_TABLE_PRIVILEGES = 20;</code> + */ + public static final int GET_TABLE_PRIVILEGES_VALUE = 20; + /** + * <code>GET_TABLES = 21;</code> + */ + public static final int GET_TABLES_VALUE = 21; + /** + * <code>GET_TABLE_TYPES = 22;</code> + */ + public static final int GET_TABLE_TYPES_VALUE = 22; + /** + * <code>GET_TYPE_INFO = 23;</code> + */ + public static final int GET_TYPE_INFO_VALUE = 23; + /** + * <code>GET_UDTS = 24;</code> + */ + public static final int GET_UDTS_VALUE = 24; + /** + * <code>GET_VERSION_COLUMNS = 25;</code> + */ + public static final int GET_VERSION_COLUMNS_VALUE = 25; + + + public final int getNumber() { + if (index == -1) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + public static MetaDataOperation valueOf(int value) { + switch (value) { + case 0: return GET_ATTRIBUTES; + case 1: return GET_BEST_ROW_IDENTIFIER; + case 2: return GET_CATALOGS; + case 3: return GET_CLIENT_INFO_PROPERTIES; + case 4: return GET_COLUMN_PRIVILEGES; + case 5: return GET_COLUMNS; + case 6: return GET_CROSS_REFERENCE; + case 7: return GET_EXPORTED_KEYS; + case 8: return GET_FUNCTION_COLUMNS; + case 9: return GET_FUNCTIONS; + case 10: return GET_IMPORTED_KEYS; + case 11: return GET_INDEX_INFO; + case 12: return GET_PRIMARY_KEYS; + case 13: return GET_PROCEDURE_COLUMNS; + case 14: return GET_PROCEDURES; + case 15: return GET_PSEUDO_COLUMNS; + case 16: return GET_SCHEMAS; + case 17: return GET_SCHEMAS_WITH_ARGS; + case 18: return GET_SUPER_TABLES; + case 19: return GET_SUPER_TYPES; + case 20: return GET_TABLE_PRIVILEGES; + case 21: return GET_TABLES; + case 22: return GET_TABLE_TYPES; + case 23: return GET_TYPE_INFO; + case 24: return GET_UDTS; + case 25: return GET_VERSION_COLUMNS; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap<MetaDataOperation> + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + MetaDataOperation> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap<MetaDataOperation>() { + public MetaDataOperation findValueByNumber(int number) { + return MetaDataOperation.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.apache.calcite.avatica.proto.Common.getDescriptor().getEnumTypes().get(3); + } + + private static final MetaDataOperation[] VALUES = values(); + + public static MetaDataOperation valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private MetaDataOperation(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:MetaDataOperation) + } + + /** + * Protobuf enum {@code StateType} + */ + public enum StateType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * <code>SQL = 0;</code> + */ + SQL(0, 0), + /** + * <code>METADATA = 1;</code> + */ + METADATA(1, 1), + UNRECOGNIZED(-1, -1), + ; + + /** + * <code>SQL = 0;</code> + */ + public static final int SQL_VALUE = 0; + /** + * <code>METADATA = 1;</code> + */ + public static final int METADATA_VALUE = 1; + + + public final int getNumber() { + if (index == -1) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + public static StateType valueOf(int value) { + switch (value) { + case 0: return SQL; + case 1: return METADATA; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap<StateType> + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + StateType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap<StateType>() { + public StateType findValueByNumber(int number) { + return StateType.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.apache.calcite.avatica.proto.Common.getDescriptor().getEnumTypes().get(4); + } + + private static final StateType[] VALUES = values(); + + public static StateType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private StateType(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:StateType) + } + public interface ConnectionPropertiesOrBuilder extends // @@protoc_insertion_point(interface_extends:ConnectionProperties) com.google.protobuf.MessageOrBuilder { @@ -13383,25 +13787,2340 @@ package org.apache.calcite.avatica.proto; } - private static com.google.protobuf.Descriptors.Descriptor - internal_static_ConnectionProperties_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_ConnectionProperties_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_StatementHandle_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_StatementHandle_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_Signature_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_Signature_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_ColumnMetaData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable + public interface MetaDataOperationArgumentOrBuilder extends + // @@protoc_insertion_point(interface_extends:MetaDataOperationArgument) + com.google.protobuf.MessageOrBuilder { + + /** + * <code>optional string string_value = 1;</code> + */ + java.lang.String getStringValue(); + /** + * <code>optional string string_value = 1;</code> + */ + com.google.protobuf.ByteString + getStringValueBytes(); + + /** + * <code>optional bool bool_value = 2;</code> + */ + boolean getBoolValue(); + + /** + * <code>optional sint32 int_value = 3;</code> + */ + int getIntValue(); + + /** + * <code>repeated string string_array_values = 4;</code> + */ + com.google.protobuf.ProtocolStringList + getStringArrayValuesList(); + /** + * <code>repeated string string_array_values = 4;</code> + */ + int getStringArrayValuesCount(); + /** + * <code>repeated string string_array_values = 4;</code> + */ + java.lang.String getStringArrayValues(int index); + /** + * <code>repeated string string_array_values = 4;</code> + */ + com.google.protobuf.ByteString + getStringArrayValuesBytes(int index); + + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + java.util.List<java.lang.Integer> getIntArrayValuesList(); + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + int getIntArrayValuesCount(); + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + int getIntArrayValues(int index); + + /** + * <code>optional .MetaDataOperationArgument.ArgumentType type = 6;</code> + */ + int getTypeValue(); + /** + * <code>optional .MetaDataOperationArgument.ArgumentType type = 6;</code> + */ + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType getType(); + } + /** + * Protobuf type {@code MetaDataOperationArgument} + * + * <pre> + * Represents the breadth of arguments to DatabaseMetaData functions + * </pre> + */ + public static final class MetaDataOperationArgument extends + com.google.protobuf.GeneratedMessage implements + // @@protoc_insertion_point(message_implements:MetaDataOperationArgument) + MetaDataOperationArgumentOrBuilder { + // Use MetaDataOperationArgument.newBuilder() to construct. + private MetaDataOperationArgument(com.google.protobuf.GeneratedMessage.Builder<?> builder) { + super(builder); + } + private MetaDataOperationArgument() { + stringValue_ = ""; + boolValue_ = false; + intValue_ = 0; + stringArrayValues_ = com.google.protobuf.LazyStringArrayList.EMPTY; + intArrayValues_ = java.util.Collections.emptyList(); + type_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private MetaDataOperationArgument( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + String s = input.readStringRequireUtf8(); + + stringValue_ = s; + break; + } + case 16: { + + boolValue_ = input.readBool(); + break; + } + case 24: { + + intValue_ = input.readSInt32(); + break; + } + case 34: { + String s = input.readStringRequireUtf8(); + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + stringArrayValues_ = new com.google.protobuf.LazyStringArrayList(); + mutable_bitField0_ |= 0x00000008; + } + stringArrayValues_.add(s); + break; + } + case 40: { + if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + intArrayValues_ = new java.util.ArrayList<java.lang.Integer>(); + mutable_bitField0_ |= 0x00000010; + } + intArrayValues_.add(input.readSInt32()); + break; + } + case 42: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) { + intArrayValues_ = new java.util.ArrayList<java.lang.Integer>(); + mutable_bitField0_ |= 0x00000010; + } + while (input.getBytesUntilLimit() > 0) { + intArrayValues_.add(input.readSInt32()); + } + input.popLimit(limit); + break; + } + case 48: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw new RuntimeException(e.setUnfinishedMessage(this)); + } catch (java.io.IOException e) { + throw new RuntimeException( + new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this)); + } finally { + if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + stringArrayValues_ = stringArrayValues_.getUnmodifiableView(); + } + if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + intArrayValues_ = java.util.Collections.unmodifiableList(intArrayValues_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.calcite.avatica.proto.Common.internal_static_MetaDataOperationArgument_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.calcite.avatica.proto.Common.internal_static_MetaDataOperationArgument_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.class, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder.class); + } + + /** + * Protobuf enum {@code MetaDataOperationArgument.ArgumentType} + */ + public enum ArgumentType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * <code>STRING = 0;</code> + */ + STRING(0, 0), + /** + * <code>BOOL = 1;</code> + */ + BOOL(1, 1), + /** + * <code>INT = 2;</code> + */ + INT(2, 2), + /** + * <code>REPEATED_STRING = 3;</code> + */ + REPEATED_STRING(3, 3), + /** + * <code>REPEATED_INT = 4;</code> + */ + REPEATED_INT(4, 4), + /** + * <code>NULL = 5;</code> + */ + NULL(5, 5), + UNRECOGNIZED(-1, -1), + ; + + /** + * <code>STRING = 0;</code> + */ + public static final int STRING_VALUE = 0; + /** + * <code>BOOL = 1;</code> + */ + public static final int BOOL_VALUE = 1; + /** + * <code>INT = 2;</code> + */ + public static final int INT_VALUE = 2; + /** + * <code>REPEATED_STRING = 3;</code> + */ + public static final int REPEATED_STRING_VALUE = 3; + /** + * <code>REPEATED_INT = 4;</code> + */ + public static final int REPEATED_INT_VALUE = 4; + /** + * <code>NULL = 5;</code> + */ + public static final int NULL_VALUE = 5; + + + public final int getNumber() { + if (index == -1) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + public static ArgumentType valueOf(int value) { + switch (value) { + case 0: return STRING; + case 1: return BOOL; + case 2: return INT; + case 3: return REPEATED_STRING; + case 4: return REPEATED_INT; + case 5: return NULL; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap<ArgumentType> + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + ArgumentType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap<ArgumentType>() { + public ArgumentType findValueByNumber(int number) { + return ArgumentType.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.getDescriptor().getEnumTypes().get(0); + } + + private static final ArgumentType[] VALUES = values(); + + public static ArgumentType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private ArgumentType(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:MetaDataOperationArgument.ArgumentType) + } + + private int bitField0_; + public static final int STRING_VALUE_FIELD_NUMBER = 1; + private volatile java.lang.Object stringValue_; + /** + * <code>optional string string_value = 1;</code> + */ + public java.lang.String getStringValue() { + java.lang.Object ref = stringValue_; + 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(); + stringValue_ = s; + return s; + } + } + /** + * <code>optional string string_value = 1;</code> + */ + public com.google.protobuf.ByteString + getStringValueBytes() { + java.lang.Object ref = stringValue_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + stringValue_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int BOOL_VALUE_FIELD_NUMBER = 2; + private boolean boolValue_; + /** + * <code>optional bool bool_value = 2;</code> + */ + public boolean getBoolValue() { + return boolValue_; + } + + public static final int INT_VALUE_FIELD_NUMBER = 3; + private int intValue_; + /** + * <code>optional sint32 int_value = 3;</code> + */ + public int getIntValue() { + return intValue_; + } + + public static final int STRING_ARRAY_VALUES_FIELD_NUMBER = 4; + private com.google.protobuf.LazyStringList stringArrayValues_; + /** + * <code>repeated string string_array_values = 4;</code> + */ + public com.google.protobuf.ProtocolStringList + getStringArrayValuesList() { + return stringArrayValues_; + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public int getStringArrayValuesCount() { + return stringArrayValues_.size(); + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public java.lang.String getStringArrayValues(int index) { + return stringArrayValues_.get(index); + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public com.google.protobuf.ByteString + getStringArrayValuesBytes(int index) { + return stringArrayValues_.getByteString(index); + } + + public static final int INT_ARRAY_VALUES_FIELD_NUMBER = 5; + private java.util.List<java.lang.Integer> intArrayValues_; + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public java.util.List<java.lang.Integer> + getIntArrayValuesList() { + return intArrayValues_; + } + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public int getIntArrayValuesCount() { + return intArrayValues_.size(); + } + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public int getIntArrayValues(int index) { + return intArrayValues_.get(index); + } + private int intArrayValuesMemoizedSerializedSize = -1; + + public static final int TYPE_FIELD_NUMBER = 6; + private int type_; + /** + * <code>optional .MetaDataOperationArgument.ArgumentType type = 6;</code> + */ + public int getTypeValue() { + return type_; + } + /** + * <code>optional .MetaDataOperationArgument.ArgumentType type = 6;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType getType() { + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType result = org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType.valueOf(type_); + return result == null ? org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType.UNRECOGNIZED : result; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (!getStringValueBytes().isEmpty()) { + com.google.protobuf.GeneratedMessage.writeString(output, 1, stringValue_); + } + if (boolValue_ != false) { + output.writeBool(2, boolValue_); + } + if (intValue_ != 0) { + output.writeSInt32(3, intValue_); + } + for (int i = 0; i < stringArrayValues_.size(); i++) { + com.google.protobuf.GeneratedMessage.writeString(output, 4, stringArrayValues_.getRaw(i)); + } + if (getIntArrayValuesList().size() > 0) { + output.writeRawVarint32(42); + output.writeRawVarint32(intArrayValuesMemoizedSerializedSize); + } + for (int i = 0; i < intArrayValues_.size(); i++) { + output.writeSInt32NoTag(intArrayValues_.get(i)); + } + if (type_ != org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType.STRING.getNumber()) { + output.writeEnum(6, type_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getStringValueBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessage.computeStringSize(1, stringValue_); + } + if (boolValue_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(2, boolValue_); + } + if (intValue_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeSInt32Size(3, intValue_); + } + { + int dataSize = 0; + for (int i = 0; i < stringArrayValues_.size(); i++) { + dataSize += computeStringSizeNoTag(stringArrayValues_.getRaw(i)); + } + size += dataSize; + size += 1 * getStringArrayValuesList().size(); + } + { + int dataSize = 0; + for (int i = 0; i < intArrayValues_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeSInt32SizeNoTag(intArrayValues_.get(i)); + } + size += dataSize; + if (!getIntArrayValuesList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + intArrayValuesMemoizedSerializedSize = dataSize; + } + if (type_ != org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType.STRING.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(6, type_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument 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.calcite.avatica.proto.Common.MetaDataOperationArgument parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code MetaDataOperationArgument} + * + * <pre> + * Represents the breadth of arguments to DatabaseMetaData functions + * </pre> + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder<Builder> implements + // @@protoc_insertion_point(builder_implements:MetaDataOperationArgument) + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.calcite.avatica.proto.Common.internal_static_MetaDataOperationArgument_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.calcite.avatica.proto.Common.internal_static_MetaDataOperationArgument_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.class, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder.class); + } + + // Construct using org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + stringValue_ = ""; + + boolValue_ = false; + + intValue_ = 0; + + stringArrayValues_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000008); + intArrayValues_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + type_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.apache.calcite.avatica.proto.Common.internal_static_MetaDataOperationArgument_descriptor; + } + + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument getDefaultInstanceForType() { + return org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.getDefaultInstance(); + } + + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument build() { + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument buildPartial() { + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument result = new org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.stringValue_ = stringValue_; + result.boolValue_ = boolValue_; + result.intValue_ = intValue_; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + stringArrayValues_ = stringArrayValues_.getUnmodifiableView(); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.stringArrayValues_ = stringArrayValues_; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + intArrayValues_ = java.util.Collections.unmodifiableList(intArrayValues_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.intArrayValues_ = intArrayValues_; + result.type_ = type_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument) { + return mergeFrom((org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument other) { + if (other == org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.getDefaultInstance()) return this; + if (!other.getStringValue().isEmpty()) { + stringValue_ = other.stringValue_; + onChanged(); + } + if (other.getBoolValue() != false) { + setBoolValue(other.getBoolValue()); + } + if (other.getIntValue() != 0) { + setIntValue(other.getIntValue()); + } + if (!other.stringArrayValues_.isEmpty()) { + if (stringArrayValues_.isEmpty()) { + stringArrayValues_ = other.stringArrayValues_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureStringArrayValuesIsMutable(); + stringArrayValues_.addAll(other.stringArrayValues_); + } + onChanged(); + } + if (!other.intArrayValues_.isEmpty()) { + if (intArrayValues_.isEmpty()) { + intArrayValues_ = other.intArrayValues_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureIntArrayValuesIsMutable(); + intArrayValues_.addAll(other.intArrayValues_); + } + onChanged(); + } + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object stringValue_ = ""; + /** + * <code>optional string string_value = 1;</code> + */ + public java.lang.String getStringValue() { + java.lang.Object ref = stringValue_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + stringValue_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * <code>optional string string_value = 1;</code> + */ + public com.google.protobuf.ByteString + getStringValueBytes() { + java.lang.Object ref = stringValue_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + stringValue_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * <code>optional string string_value = 1;</code> + */ + public Builder setStringValue( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + stringValue_ = value; + onChanged(); + return this; + } + /** + * <code>optional string string_value = 1;</code> + */ + public Builder clearStringValue() { + + stringValue_ = getDefaultInstance().getStringValue(); + onChanged(); + return this; + } + /** + * <code>optional string string_value = 1;</code> + */ + public Builder setStringValueBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + stringValue_ = value; + onChanged(); + return this; + } + + private boolean boolValue_ ; + /** + * <code>optional bool bool_value = 2;</code> + */ + public boolean getBoolValue() { + return boolValue_; + } + /** + * <code>optional bool bool_value = 2;</code> + */ + public Builder setBoolValue(boolean value) { + + boolValue_ = value; + onChanged(); + return this; + } + /** + * <code>optional bool bool_value = 2;</code> + */ + public Builder clearBoolValue() { + + boolValue_ = false; + onChanged(); + return this; + } + + private int intValue_ ; + /** + * <code>optional sint32 int_value = 3;</code> + */ + public int getIntValue() { + return intValue_; + } + /** + * <code>optional sint32 int_value = 3;</code> + */ + public Builder setIntValue(int value) { + + intValue_ = value; + onChanged(); + return this; + } + /** + * <code>optional sint32 int_value = 3;</code> + */ + public Builder clearIntValue() { + + intValue_ = 0; + onChanged(); + return this; + } + + private com.google.protobuf.LazyStringList stringArrayValues_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureStringArrayValuesIsMutable() { + if (!((bitField0_ & 0x00000008) == 0x00000008)) { + stringArrayValues_ = new com.google.protobuf.LazyStringArrayList(stringArrayValues_); + bitField0_ |= 0x00000008; + } + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public com.google.protobuf.ProtocolStringList + getStringArrayValuesList() { + return stringArrayValues_.getUnmodifiableView(); + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public int getStringArrayValuesCount() { + return stringArrayValues_.size(); + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public java.lang.String getStringArrayValues(int index) { + return stringArrayValues_.get(index); + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public com.google.protobuf.ByteString + getStringArrayValuesBytes(int index) { + return stringArrayValues_.getByteString(index); + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public Builder setStringArrayValues( + int index, java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStringArrayValuesIsMutable(); + stringArrayValues_.set(index, value); + onChanged(); + return this; + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public Builder addStringArrayValues( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStringArrayValuesIsMutable(); + stringArrayValues_.add(value); + onChanged(); + return this; + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public Builder addAllStringArrayValues( + java.lang.Iterable<java.lang.String> values) { + ensureStringArrayValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, stringArrayValues_); + onChanged(); + return this; + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public Builder clearStringArrayValues() { + stringArrayValues_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + return this; + } + /** + * <code>repeated string string_array_values = 4;</code> + */ + public Builder addStringArrayValuesBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + ensureStringArrayValuesIsMutable(); + stringArrayValues_.add(value); + onChanged(); + return this; + } + + private java.util.List<java.lang.Integer> intArrayValues_ = java.util.Collections.emptyList(); + private void ensureIntArrayValuesIsMutable() { + if (!((bitField0_ & 0x00000010) == 0x00000010)) { + intArrayValues_ = new java.util.ArrayList<java.lang.Integer>(intArrayValues_); + bitField0_ |= 0x00000010; + } + } + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public java.util.List<java.lang.Integer> + getIntArrayValuesList() { + return java.util.Collections.unmodifiableList(intArrayValues_); + } + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public int getIntArrayValuesCount() { + return intArrayValues_.size(); + } + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public int getIntArrayValues(int index) { + return intArrayValues_.get(index); + } + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public Builder setIntArrayValues( + int index, int value) { + ensureIntArrayValuesIsMutable(); + intArrayValues_.set(index, value); + onChanged(); + return this; + } + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public Builder addIntArrayValues(int value) { + ensureIntArrayValuesIsMutable(); + intArrayValues_.add(value); + onChanged(); + return this; + } + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public Builder addAllIntArrayValues( + java.lang.Iterable<? extends java.lang.Integer> values) { + ensureIntArrayValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, intArrayValues_); + onChanged(); + return this; + } + /** + * <code>repeated sint32 int_array_values = 5;</code> + */ + public Builder clearIntArrayValues() { + intArrayValues_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + return this; + } + + private int type_ = 0; + /** + * <code>optional .MetaDataOperationArgument.ArgumentType type = 6;</code> + */ + public int getTypeValue() { + return type_; + } + /** + * <code>optional .MetaDataOperationArgument.ArgumentType type = 6;</code> + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * <code>optional .MetaDataOperationArgument.ArgumentType type = 6;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType getType() { + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType result = org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType.valueOf(type_); + return result == null ? org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType.UNRECOGNIZED : result; + } + /** + * <code>optional .MetaDataOperationArgument.ArgumentType type = 6;</code> + */ + public Builder setType(org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.ArgumentType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * <code>optional .MetaDataOperationArgument.ArgumentType type = 6;</code> + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:MetaDataOperationArgument) + } + + // @@protoc_insertion_point(class_scope:MetaDataOperationArgument) + private static final org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument(); + } + + public static org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser<MetaDataOperationArgument> + PARSER = new com.google.protobuf.AbstractParser<MetaDataOperationArgument>() { + public MetaDataOperationArgument parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + try { + return new MetaDataOperationArgument(input, extensionRegistry); + } catch (RuntimeException e) { + if (e.getCause() instanceof + com.google.protobuf.InvalidProtocolBufferException) { + throw (com.google.protobuf.InvalidProtocolBufferException) + e.getCause(); + } + throw e; + } + } + }; + + public static com.google.protobuf.Parser<MetaDataOperationArgument> parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser<MetaDataOperationArgument> getParserForType() { + return PARSER; + } + + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface QueryStateOrBuilder extends + // @@protoc_insertion_point(interface_extends:QueryState) + com.google.protobuf.MessageOrBuilder { + + /** + * <code>optional .StateType type = 1;</code> + */ + int getTypeValue(); + /** + * <code>optional .StateType type = 1;</code> + */ + org.apache.calcite.avatica.proto.Common.StateType getType(); + + /** + * <code>optional string sql = 2;</code> + */ + java.lang.String getSql(); + /** + * <code>optional string sql = 2;</code> + */ + com.google.protobuf.ByteString + getSqlBytes(); + + /** + * <code>optional .MetaDataOperation op = 3;</code> + */ + int getOpValue(); + /** + * <code>optional .MetaDataOperation op = 3;</code> + */ + org.apache.calcite.avatica.proto.Common.MetaDataOperation getOp(); + + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + java.util.List<org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument> + getArgsList(); + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument getArgs(int index); + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + int getArgsCount(); + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + java.util.List<? extends org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder> + getArgsOrBuilderList(); + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder getArgsOrBuilder( + int index); + + /** + * <code>optional bool has_args = 5;</code> + */ + boolean getHasArgs(); + + /** + * <code>optional bool has_sql = 6;</code> + */ + boolean getHasSql(); + + /** + * <code>optional bool has_op = 7;</code> + */ + boolean getHasOp(); + } + /** + * Protobuf type {@code QueryState} + */ + public static final class QueryState extends + com.google.protobuf.GeneratedMessage implements + // @@protoc_insertion_point(message_implements:QueryState) + QueryStateOrBuilder { + // Use QueryState.newBuilder() to construct. + private QueryState(com.google.protobuf.GeneratedMessage.Builder<?> builder) { + super(builder); + } + private QueryState() { + type_ = 0; + sql_ = ""; + op_ = 0; + args_ = java.util.Collections.emptyList(); + hasArgs_ = false; + hasSql_ = false; + hasOp_ = false; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private QueryState( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + case 18: { + String s = input.readStringRequireUtf8(); + + sql_ = s; + break; + } + case 24: { + int rawValue = input.readEnum(); + + op_ = rawValue; + break; + } + case 34: { + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + args_ = new java.util.ArrayList<org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument>(); + mutable_bitField0_ |= 0x00000008; + } + args_.add(input.readMessage(org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.parser(), extensionRegistry)); + break; + } + case 40: { + + hasArgs_ = input.readBool(); + break; + } + case 48: { + + hasSql_ = input.readBool(); + break; + } + case 56: { + + hasOp_ = input.readBool(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw new RuntimeException(e.setUnfinishedMessage(this)); + } catch (java.io.IOException e) { + throw new RuntimeException( + new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this)); + } finally { + if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + args_ = java.util.Collections.unmodifiableList(args_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.calcite.avatica.proto.Common.internal_static_QueryState_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.calcite.avatica.proto.Common.internal_static_QueryState_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.apache.calcite.avatica.proto.Common.QueryState.class, org.apache.calcite.avatica.proto.Common.QueryState.Builder.class); + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * <code>optional .StateType type = 1;</code> + */ + public int getTypeValue() { + return type_; + } + /** + * <code>optional .StateType type = 1;</code> + */ + public org.apache.calcite.avatica.proto.Common.StateType getType() { + org.apache.calcite.avatica.proto.Common.StateType result = org.apache.calcite.avatica.proto.Common.StateType.valueOf(type_); + return result == null ? org.apache.calcite.avatica.proto.Common.StateType.UNRECOGNIZED : result; + } + + public static final int SQL_FIELD_NUMBER = 2; + private volatile java.lang.Object sql_; + /** + * <code>optional string sql = 2;</code> + */ + public java.lang.String getSql() { + java.lang.Object ref = sql_; + 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(); + sql_ = s; + return s; + } + } + /** + * <code>optional string sql = 2;</code> + */ + public com.google.protobuf.ByteString + getSqlBytes() { + java.lang.Object ref = sql_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + sql_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int OP_FIELD_NUMBER = 3; + private int op_; + /** + * <code>optional .MetaDataOperation op = 3;</code> + */ + public int getOpValue() { + return op_; + } + /** + * <code>optional .MetaDataOperation op = 3;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperation getOp() { + org.apache.calcite.avatica.proto.Common.MetaDataOperation result = org.apache.calcite.avatica.proto.Common.MetaDataOperation.valueOf(op_); + return result == null ? org.apache.calcite.avatica.proto.Common.MetaDataOperation.UNRECOGNIZED : result; + } + + public static final int ARGS_FIELD_NUMBER = 4; + private java.util.List<org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument> args_; + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public java.util.List<org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument> getArgsList() { + return args_; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public java.util.List<? extends org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder> + getArgsOrBuilderList() { + return args_; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public int getArgsCount() { + return args_.size(); + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument getArgs(int index) { + return args_.get(index); + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder getArgsOrBuilder( + int index) { + return args_.get(index); + } + + public static final int HAS_ARGS_FIELD_NUMBER = 5; + private boolean hasArgs_; + /** + * <code>optional bool has_args = 5;</code> + */ + public boolean getHasArgs() { + return hasArgs_; + } + + public static final int HAS_SQL_FIELD_NUMBER = 6; + private boolean hasSql_; + /** + * <code>optional bool has_sql = 6;</code> + */ + public boolean getHasSql() { + return hasSql_; + } + + public static final int HAS_OP_FIELD_NUMBER = 7; + private boolean hasOp_; + /** + * <code>optional bool has_op = 7;</code> + */ + public boolean getHasOp() { + return hasOp_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (type_ != org.apache.calcite.avatica.proto.Common.StateType.SQL.getNumber()) { + output.writeEnum(1, type_); + } + if (!getSqlBytes().isEmpty()) { + com.google.protobuf.GeneratedMessage.writeString(output, 2, sql_); + } + if (op_ != org.apache.calcite.avatica.proto.Common.MetaDataOperation.GET_ATTRIBUTES.getNumber()) { + output.writeEnum(3, op_); + } + for (int i = 0; i < args_.size(); i++) { + output.writeMessage(4, args_.get(i)); + } + if (hasArgs_ != false) { + output.writeBool(5, hasArgs_); + } + if (hasSql_ != false) { + output.writeBool(6, hasSql_); + } + if (hasOp_ != false) { + output.writeBool(7, hasOp_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (type_ != org.apache.calcite.avatica.proto.Common.StateType.SQL.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (!getSqlBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessage.computeStringSize(2, sql_); + } + if (op_ != org.apache.calcite.avatica.proto.Common.MetaDataOperation.GET_ATTRIBUTES.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, op_); + } + for (int i = 0; i < args_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, args_.get(i)); + } + if (hasArgs_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(5, hasArgs_); + } + if (hasSql_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(6, hasSql_); + } + if (hasOp_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(7, hasOp_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + public static org.apache.calcite.avatica.proto.Common.QueryState parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.apache.calcite.avatica.proto.Common.QueryState 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.calcite.avatica.proto.Common.QueryState parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.apache.calcite.avatica.proto.Common.QueryState parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.apache.calcite.avatica.proto.Common.QueryState parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.apache.calcite.avatica.proto.Common.QueryState parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.apache.calcite.avatica.proto.Common.QueryState parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.apache.calcite.avatica.proto.Common.QueryState parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.apache.calcite.avatica.proto.Common.QueryState parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.apache.calcite.avatica.proto.Common.QueryState parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(org.apache.calcite.avatica.proto.Common.QueryState prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code QueryState} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder<Builder> implements + // @@protoc_insertion_point(builder_implements:QueryState) + org.apache.calcite.avatica.proto.Common.QueryStateOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.calcite.avatica.proto.Common.internal_static_QueryState_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.calcite.avatica.proto.Common.internal_static_QueryState_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.apache.calcite.avatica.proto.Common.QueryState.class, org.apache.calcite.avatica.proto.Common.QueryState.Builder.class); + } + + // Construct using org.apache.calcite.avatica.proto.Common.QueryState.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getArgsFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + type_ = 0; + + sql_ = ""; + + op_ = 0; + + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + } else { + argsBuilder_.clear(); + } + hasArgs_ = false; + + hasSql_ = false; + + hasOp_ = false; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.apache.calcite.avatica.proto.Common.internal_static_QueryState_descriptor; + } + + public org.apache.calcite.avatica.proto.Common.QueryState getDefaultInstanceForType() { + return org.apache.calcite.avatica.proto.Common.QueryState.getDefaultInstance(); + } + + public org.apache.calcite.avatica.proto.Common.QueryState build() { + org.apache.calcite.avatica.proto.Common.QueryState result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.apache.calcite.avatica.proto.Common.QueryState buildPartial() { + org.apache.calcite.avatica.proto.Common.QueryState result = new org.apache.calcite.avatica.proto.Common.QueryState(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.type_ = type_; + result.sql_ = sql_; + result.op_ = op_; + if (argsBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008)) { + args_ = java.util.Collections.unmodifiableList(args_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.args_ = args_; + } else { + result.args_ = argsBuilder_.build(); + } + result.hasArgs_ = hasArgs_; + result.hasSql_ = hasSql_; + result.hasOp_ = hasOp_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.apache.calcite.avatica.proto.Common.QueryState) { + return mergeFrom((org.apache.calcite.avatica.proto.Common.QueryState)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.apache.calcite.avatica.proto.Common.QueryState other) { + if (other == org.apache.calcite.avatica.proto.Common.QueryState.getDefaultInstance()) return this; + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + if (!other.getSql().isEmpty()) { + sql_ = other.sql_; + onChanged(); + } + if (other.op_ != 0) { + setOpValue(other.getOpValue()); + } + if (argsBuilder_ == null) { + if (!other.args_.isEmpty()) { + if (args_.isEmpty()) { + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureArgsIsMutable(); + args_.addAll(other.args_); + } + onChanged(); + } + } else { + if (!other.args_.isEmpty()) { + if (argsBuilder_.isEmpty()) { + argsBuilder_.dispose(); + argsBuilder_ = null; + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000008); + argsBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getArgsFieldBuilder() : null; + } else { + argsBuilder_.addAllMessages(other.args_); + } + } + } + if (other.getHasArgs() != false) { + setHasArgs(other.getHasArgs()); + } + if (other.getHasSql() != false) { + setHasSql(other.getHasSql()); + } + if (other.getHasOp() != false) { + setHasOp(other.getHasOp()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.apache.calcite.avatica.proto.Common.QueryState parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.apache.calcite.avatica.proto.Common.QueryState) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ = 0; + /** + * <code>optional .StateType type = 1;</code> + */ + public int getTypeValue() { + return type_; + } + /** + * <code>optional .StateType type = 1;</code> + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * <code>optional .StateType type = 1;</code> + */ + public org.apache.calcite.avatica.proto.Common.StateType getType() { + org.apache.calcite.avatica.proto.Common.StateType result = org.apache.calcite.avatica.proto.Common.StateType.valueOf(type_); + return result == null ? org.apache.calcite.avatica.proto.Common.StateType.UNRECOGNIZED : result; + } + /** + * <code>optional .StateType type = 1;</code> + */ + public Builder setType(org.apache.calcite.avatica.proto.Common.StateType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * <code>optional .StateType type = 1;</code> + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + + private java.lang.Object sql_ = ""; + /** + * <code>optional string sql = 2;</code> + */ + public java.lang.String getSql() { + java.lang.Object ref = sql_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + sql_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * <code>optional string sql = 2;</code> + */ + public com.google.protobuf.ByteString + getSqlBytes() { + java.lang.Object ref = sql_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + sql_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * <code>optional string sql = 2;</code> + */ + public Builder setSql( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + sql_ = value; + onChanged(); + return this; + } + /** + * <code>optional string sql = 2;</code> + */ + public Builder clearSql() { + + sql_ = getDefaultInstance().getSql(); + onChanged(); + return this; + } + /** + * <code>optional string sql = 2;</code> + */ + public Builder setSqlBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + sql_ = value; + onChanged(); + return this; + } + + private int op_ = 0; + /** + * <code>optional .MetaDataOperation op = 3;</code> + */ + public int getOpValue() { + return op_; + } + /** + * <code>optional .MetaDataOperation op = 3;</code> + */ + public Builder setOpValue(int value) { + op_ = value; + onChanged(); + return this; + } + /** + * <code>optional .MetaDataOperation op = 3;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperation getOp() { + org.apache.calcite.avatica.proto.Common.MetaDataOperation result = org.apache.calcite.avatica.proto.Common.MetaDataOperation.valueOf(op_); + return result == null ? org.apache.calcite.avatica.proto.Common.MetaDataOperation.UNRECOGNIZED : result; + } + /** + * <code>optional .MetaDataOperation op = 3;</code> + */ + public Builder setOp(org.apache.calcite.avatica.proto.Common.MetaDataOperation value) { + if (value == null) { + throw new NullPointerException(); + } + + op_ = value.getNumber(); + onChanged(); + return this; + } + /** + * <code>optional .MetaDataOperation op = 3;</code> + */ + public Builder clearOp() { + + op_ = 0; + onChanged(); + return this; + } + + private java.util.List<org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument> args_ = + java.util.Collections.emptyList(); + private void ensureArgsIsMutable() { + if (!((bitField0_ & 0x00000008) == 0x00000008)) { + args_ = new java.util.ArrayList<org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument>(args_); + bitField0_ |= 0x00000008; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder> argsBuilder_; + + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public java.util.List<org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument> getArgsList() { + if (argsBuilder_ == null) { + return java.util.Collections.unmodifiableList(args_); + } else { + return argsBuilder_.getMessageList(); + } + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public int getArgsCount() { + if (argsBuilder_ == null) { + return args_.size(); + } else { + return argsBuilder_.getCount(); + } + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument getArgs(int index) { + if (argsBuilder_ == null) { + return args_.get(index); + } else { + return argsBuilder_.getMessage(index); + } + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public Builder setArgs( + int index, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.set(index, value); + onChanged(); + } else { + argsBuilder_.setMessage(index, value); + } + return this; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public Builder setArgs( + int index, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.set(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public Builder addArgs(org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(value); + onChanged(); + } else { + argsBuilder_.addMessage(value); + } + return this; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public Builder addArgs( + int index, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(index, value); + onChanged(); + } else { + argsBuilder_.addMessage(index, value); + } + return this; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public Builder addArgs( + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public Builder addArgs( + int index, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public Builder addAllArgs( + java.lang.Iterable<? extends org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument> values) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, args_); + onChanged(); + } else { + argsBuilder_.addAllMessages(values); + } + return this; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public Builder clearArgs() { + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + } else { + argsBuilder_.clear(); + } + return this; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public Builder removeArgs(int index) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.remove(index); + onChanged(); + } else { + argsBuilder_.remove(index); + } + return this; + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder getArgsBuilder( + int index) { + return getArgsFieldBuilder().getBuilder(index); + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder getArgsOrBuilder( + int index) { + if (argsBuilder_ == null) { + return args_.get(index); } else { + return argsBuilder_.getMessageOrBuilder(index); + } + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public java.util.List<? extends org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder> + getArgsOrBuilderList() { + if (argsBuilder_ != null) { + return argsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(args_); + } + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder addArgsBuilder() { + return getArgsFieldBuilder().addBuilder( + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.getDefaultInstance()); + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder addArgsBuilder( + int index) { + return getArgsFieldBuilder().addBuilder( + index, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.getDefaultInstance()); + } + /** + * <code>repeated .MetaDataOperationArgument args = 4;</code> + */ + public java.util.List<org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder> + getArgsBuilderList() { + return getArgsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder> + getArgsFieldBuilder() { + if (argsBuilder_ == null) { + argsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgument.Builder, org.apache.calcite.avatica.proto.Common.MetaDataOperationArgumentOrBuilder>( + args_, + ((bitFiel
<TRUNCATED>
