public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_sessionHandle = false;
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
SessionHandle = new TSessionHandle();
await SessionHandle.ReadAsync(iprot, cancellationToken);
isset_sessionHandle = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
if (!isset_sessionHandle)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public TGetTablesReq(TSessionHandle sessionHandle) : this()
{
this.SessionHandle = sessionHandle;
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_sessionHandle = false;
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
SessionHandle = new TSessionHandle();
await SessionHandle.ReadAsync(iprot, cancellationToken);
isset_sessionHandle = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
CatalogName = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.String)
{
SchemaName = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.String)
{
TableName = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.List)
{
{
TList _list86 = await iprot.ReadListBeginAsync(cancellationToken);
TableTypes = new List <string>(_list86.Count);
for (int _i87 = 0; _i87 < _list86.Count; ++_i87)
{
string _elem88;
_elem88 = await iprot.ReadStringAsync(cancellationToken);
TableTypes.Add(_elem88);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
if (!isset_sessionHandle)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public TGetDelegationTokenReq(TSessionHandle sessionHandle, string owner, string renewer) : this()
{
this.SessionHandle = sessionHandle;
this.Owner = owner;
this.Renewer = renewer;
}
public TGetCatalogsReq(TSessionHandle sessionHandle) : this()
{
this.SessionHandle = sessionHandle;
}
public TGetInfoReq(TSessionHandle sessionHandle, TGetInfoType infoType) : this()
{
this.SessionHandle = sessionHandle;
this.InfoType = infoType;
}
public TGetPrimaryKeysReq(TSessionHandle sessionHandle) : this()
{
this.SessionHandle = sessionHandle;
}
public TGetFunctionsReq(TSessionHandle sessionHandle, string functionName) : this()
{
this.SessionHandle = sessionHandle;
this.FunctionName = functionName;
}
public TCloseSessionReq(TSessionHandle sessionHandle) : this()
{
this.SessionHandle = sessionHandle;
}
public TCancelDelegationTokenReq(TSessionHandle sessionHandle, string delegationToken) : this()
{
this.SessionHandle = sessionHandle;
this.DelegationToken = delegationToken;
}
public TGetColumnsReq(TSessionHandle sessionHandle) : this()
{
this.SessionHandle = sessionHandle;
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_sessionHandle = false;
bool isset_statement = false;
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
SessionHandle = new TSessionHandle();
await SessionHandle.ReadAsync(iprot, cancellationToken);
isset_sessionHandle = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
Statement = await iprot.ReadStringAsync(cancellationToken);
isset_statement = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
TMap _map81 = await iprot.ReadMapBeginAsync(cancellationToken);
ConfOverlay = new Dictionary <string, string>(_map81.Count);
for (int _i82 = 0; _i82 < _map81.Count; ++_i82)
{
string _key83;
string _val84;
_key83 = await iprot.ReadStringAsync(cancellationToken);
_val84 = await iprot.ReadStringAsync(cancellationToken);
ConfOverlay[_key83] = _val84;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Bool)
{
RunAsync = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.I64)
{
QueryTimeout = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
if (!isset_sessionHandle)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_statement)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public TExecuteStatementReq(TSessionHandle sessionHandle, string statement) : this()
{
this.SessionHandle = sessionHandle;
this.Statement = statement;
}
public TGetCrossReferenceReq(TSessionHandle sessionHandle) : this()
{
this.SessionHandle = sessionHandle;
}
public TGetTypeInfoReq(TSessionHandle sessionHandle) : this()
{
this.SessionHandle = sessionHandle;
}
public TGetSchemasReq(TSessionHandle sessionHandle) : this()
{
this.SessionHandle = sessionHandle;
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_status = false;
bool isset_serverProtocolVersion = false;
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
Status = new TStatus();
await Status.ReadAsync(iprot, cancellationToken);
isset_status = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I32)
{
ServerProtocolVersion = (TProtocolVersion)await iprot.ReadI32Async(cancellationToken);
isset_serverProtocolVersion = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Struct)
{
SessionHandle = new TSessionHandle();
await SessionHandle.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
TMap _map76 = await iprot.ReadMapBeginAsync(cancellationToken);
Configuration = new Dictionary <string, string>(_map76.Count);
for (int _i77 = 0; _i77 < _map76.Count; ++_i77)
{
string _key78;
string _val79;
_key78 = await iprot.ReadStringAsync(cancellationToken);
_val79 = await iprot.ReadStringAsync(cancellationToken);
Configuration[_key78] = _val79;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
if (!isset_status)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_serverProtocolVersion)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}