#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
require 5.6.0;
use strict;
use warnings;
use Thrift;
use Thrift::API::HiveClient2::Compat;
use Thrift::API::HiveClient2::Types;

# HELPER FUNCTIONS AND STRUCTURES

package Thrift::API::HiveClient2::TCLIService_OpenSession_args;
$Thrift::API::HiveClient2::TCLIService_OpenSession_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_OpenSession_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_OpenSession_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_OpenSession_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TOpenSessionReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_OpenSession_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_OpenSession_result;
$Thrift::API::HiveClient2::TCLIService_OpenSession_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_OpenSession_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_OpenSession_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_OpenSession_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TOpenSessionResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_OpenSession_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_CloseSession_args;
$Thrift::API::HiveClient2::TCLIService_CloseSession_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_CloseSession_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_CloseSession_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_CloseSession_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TCloseSessionReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_CloseSession_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_CloseSession_result;
$Thrift::API::HiveClient2::TCLIService_CloseSession_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_CloseSession_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_CloseSession_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_CloseSession_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TCloseSessionResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_CloseSession_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetInfo_args;
$Thrift::API::HiveClient2::TCLIService_GetInfo_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetInfo_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetInfo_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetInfo_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetInfoReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetInfo_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetInfo_result;
$Thrift::API::HiveClient2::TCLIService_GetInfo_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetInfo_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetInfo_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetInfo_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetInfoResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetInfo_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_ExecuteStatement_args;
$Thrift::API::HiveClient2::TCLIService_ExecuteStatement_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_ExecuteStatement_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_ExecuteStatement_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_ExecuteStatement_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TExecuteStatementReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_ExecuteStatement_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_ExecuteStatement_result;
$Thrift::API::HiveClient2::TCLIService_ExecuteStatement_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_ExecuteStatement_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_ExecuteStatement_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_ExecuteStatement_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TExecuteStatementResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_ExecuteStatement_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetTypeInfo_args;
$Thrift::API::HiveClient2::TCLIService_GetTypeInfo_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetTypeInfo_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetTypeInfo_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetTypeInfo_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetTypeInfoReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetTypeInfo_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetTypeInfo_result;
$Thrift::API::HiveClient2::TCLIService_GetTypeInfo_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetTypeInfo_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetTypeInfo_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetTypeInfo_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetTypeInfoResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetTypeInfo_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetCatalogs_args;
$Thrift::API::HiveClient2::TCLIService_GetCatalogs_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetCatalogs_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetCatalogs_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetCatalogs_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetCatalogsReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetCatalogs_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetCatalogs_result;
$Thrift::API::HiveClient2::TCLIService_GetCatalogs_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetCatalogs_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetCatalogs_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetCatalogs_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetCatalogsResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetCatalogs_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetSchemas_args;
$Thrift::API::HiveClient2::TCLIService_GetSchemas_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetSchemas_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetSchemas_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetSchemas_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetSchemasReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetSchemas_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetSchemas_result;
$Thrift::API::HiveClient2::TCLIService_GetSchemas_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetSchemas_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetSchemas_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetSchemas_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetSchemasResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetSchemas_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetTables_args;
$Thrift::API::HiveClient2::TCLIService_GetTables_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetTables_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetTables_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetTables_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetTablesReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetTables_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetTables_result;
$Thrift::API::HiveClient2::TCLIService_GetTables_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetTables_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetTables_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetTables_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetTablesResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetTables_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetTableTypes_args;
$Thrift::API::HiveClient2::TCLIService_GetTableTypes_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetTableTypes_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetTableTypes_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetTableTypes_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetTableTypesReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetTableTypes_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetTableTypes_result;
$Thrift::API::HiveClient2::TCLIService_GetTableTypes_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetTableTypes_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetTableTypes_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetTableTypes_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetTableTypesResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetTableTypes_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetColumns_args;
$Thrift::API::HiveClient2::TCLIService_GetColumns_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetColumns_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetColumns_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetColumns_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetColumnsReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetColumns_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetColumns_result;
$Thrift::API::HiveClient2::TCLIService_GetColumns_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetColumns_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetColumns_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetColumns_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetColumnsResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetColumns_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetFunctions_args;
$Thrift::API::HiveClient2::TCLIService_GetFunctions_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetFunctions_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetFunctions_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetFunctions_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetFunctionsReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetFunctions_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetFunctions_result;
$Thrift::API::HiveClient2::TCLIService_GetFunctions_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetFunctions_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetFunctions_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetFunctions_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetFunctionsResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetFunctions_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetOperationStatus_args;
$Thrift::API::HiveClient2::TCLIService_GetOperationStatus_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetOperationStatus_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetOperationStatus_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetOperationStatus_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetOperationStatusReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetOperationStatus_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetOperationStatus_result;
$Thrift::API::HiveClient2::TCLIService_GetOperationStatus_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetOperationStatus_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetOperationStatus_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetOperationStatus_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetOperationStatusResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetOperationStatus_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_CancelOperation_args;
$Thrift::API::HiveClient2::TCLIService_CancelOperation_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_CancelOperation_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_CancelOperation_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_CancelOperation_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TCancelOperationReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_CancelOperation_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_CancelOperation_result;
$Thrift::API::HiveClient2::TCLIService_CancelOperation_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_CancelOperation_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_CancelOperation_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_CancelOperation_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TCancelOperationResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_CancelOperation_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_CloseOperation_args;
$Thrift::API::HiveClient2::TCLIService_CloseOperation_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_CloseOperation_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_CloseOperation_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_CloseOperation_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TCloseOperationReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_CloseOperation_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_CloseOperation_result;
$Thrift::API::HiveClient2::TCLIService_CloseOperation_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_CloseOperation_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_CloseOperation_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_CloseOperation_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TCloseOperationResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_CloseOperation_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_args;
$Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetResultSetMetadata_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TGetResultSetMetadataReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetResultSetMetadata_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_result;
$Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_GetResultSetMetadata_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TGetResultSetMetadataResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_GetResultSetMetadata_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_FetchResults_args;
$Thrift::API::HiveClient2::TCLIService_FetchResults_args::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_FetchResults_args::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_FetchResults_args->mk_accessors( qw( req ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{req} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{req}) {
      $self->{req} = $vals->{req};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_FetchResults_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{req} = new Thrift::API::HiveClient2::TFetchResultsReq();
        $xfer += $self->{req}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_FetchResults_args');
  if (defined $self->{req}) {
    $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
    $xfer += $self->{req}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIService_FetchResults_result;
$Thrift::API::HiveClient2::TCLIService_FetchResults_result::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIService_FetchResults_result::DIST = 'Thrift-API-HiveClient2';
}
use base qw(Class::Accessor);
Thrift::API::HiveClient2::TCLIService_FetchResults_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'TCLIService_FetchResults_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = new Thrift::API::HiveClient2::TFetchResultsResp();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('TCLIService_FetchResults_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Thrift::API::HiveClient2::TCLIServiceIf;
$Thrift::API::HiveClient2::TCLIServiceIf::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIServiceIf::DIST = 'Thrift-API-HiveClient2';
}

use strict;


sub OpenSession{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub CloseSession{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetInfo{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub ExecuteStatement{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetTypeInfo{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetCatalogs{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetSchemas{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetTables{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetTableTypes{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetColumns{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetFunctions{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetOperationStatus{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub CancelOperation{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub CloseOperation{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub GetResultSetMetadata{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

sub FetchResults{
  my $self = shift;
  my $req = shift;

  die 'implement interface';
}

package Thrift::API::HiveClient2::TCLIServiceRest;
$Thrift::API::HiveClient2::TCLIServiceRest::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIServiceRest::DIST = 'Thrift-API-HiveClient2';
}

use strict;


sub new {
  my ($classname, $impl) = @_;
  my $self     ={ impl => $impl };

  return bless($self,$classname);
}

sub OpenSession{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->OpenSession($req);
}

sub CloseSession{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->CloseSession($req);
}

sub GetInfo{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetInfo($req);
}

sub ExecuteStatement{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->ExecuteStatement($req);
}

sub GetTypeInfo{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetTypeInfo($req);
}

sub GetCatalogs{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetCatalogs($req);
}

sub GetSchemas{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetSchemas($req);
}

sub GetTables{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetTables($req);
}

sub GetTableTypes{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetTableTypes($req);
}

sub GetColumns{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetColumns($req);
}

sub GetFunctions{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetFunctions($req);
}

sub GetOperationStatus{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetOperationStatus($req);
}

sub CancelOperation{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->CancelOperation($req);
}

sub CloseOperation{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->CloseOperation($req);
}

sub GetResultSetMetadata{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->GetResultSetMetadata($req);
}

sub FetchResults{
  my ($self, $request) = @_;

  my $req = ($request->{'req'}) ? $request->{'req'} : undef;
  return $self->{impl}->FetchResults($req);
}

package Thrift::API::HiveClient2::TCLIServiceClient;
$Thrift::API::HiveClient2::TCLIServiceClient::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIServiceClient::DIST = 'Thrift-API-HiveClient2';
}


use base qw(Thrift::API::HiveClient2::TCLIServiceIf);
sub new {
  my ($classname, $input, $output) = @_;
  my $self      = {};
  $self->{input}  = $input;
  $self->{output} = defined $output ? $output : $input;
  $self->{seqid}  = 0;
  return bless($self,$classname);
}

sub OpenSession{
  my $self = shift;
  my $req = shift;

    $self->send_OpenSession($req);
  return $self->recv_OpenSession();
}

sub send_OpenSession{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('OpenSession', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_OpenSession_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_OpenSession{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_OpenSession_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "OpenSession failed: unknown result";
}
sub CloseSession{
  my $self = shift;
  my $req = shift;

    $self->send_CloseSession($req);
  return $self->recv_CloseSession();
}

sub send_CloseSession{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('CloseSession', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_CloseSession_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_CloseSession{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_CloseSession_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "CloseSession failed: unknown result";
}
sub GetInfo{
  my $self = shift;
  my $req = shift;

    $self->send_GetInfo($req);
  return $self->recv_GetInfo();
}

sub send_GetInfo{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetInfo', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetInfo_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetInfo{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetInfo_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetInfo failed: unknown result";
}
sub ExecuteStatement{
  my $self = shift;
  my $req = shift;

    $self->send_ExecuteStatement($req);
  return $self->recv_ExecuteStatement();
}

sub send_ExecuteStatement{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('ExecuteStatement', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_ExecuteStatement_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_ExecuteStatement{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_ExecuteStatement_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "ExecuteStatement failed: unknown result";
}
sub GetTypeInfo{
  my $self = shift;
  my $req = shift;

    $self->send_GetTypeInfo($req);
  return $self->recv_GetTypeInfo();
}

sub send_GetTypeInfo{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetTypeInfo', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetTypeInfo_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetTypeInfo{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetTypeInfo_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetTypeInfo failed: unknown result";
}
sub GetCatalogs{
  my $self = shift;
  my $req = shift;

    $self->send_GetCatalogs($req);
  return $self->recv_GetCatalogs();
}

sub send_GetCatalogs{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetCatalogs', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetCatalogs_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetCatalogs{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetCatalogs_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetCatalogs failed: unknown result";
}
sub GetSchemas{
  my $self = shift;
  my $req = shift;

    $self->send_GetSchemas($req);
  return $self->recv_GetSchemas();
}

sub send_GetSchemas{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetSchemas', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetSchemas_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetSchemas{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetSchemas_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetSchemas failed: unknown result";
}
sub GetTables{
  my $self = shift;
  my $req = shift;

    $self->send_GetTables($req);
  return $self->recv_GetTables();
}

sub send_GetTables{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetTables', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetTables_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetTables{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetTables_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetTables failed: unknown result";
}
sub GetTableTypes{
  my $self = shift;
  my $req = shift;

    $self->send_GetTableTypes($req);
  return $self->recv_GetTableTypes();
}

sub send_GetTableTypes{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetTableTypes', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetTableTypes_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetTableTypes{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetTableTypes_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetTableTypes failed: unknown result";
}
sub GetColumns{
  my $self = shift;
  my $req = shift;

    $self->send_GetColumns($req);
  return $self->recv_GetColumns();
}

sub send_GetColumns{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetColumns', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetColumns_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetColumns{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetColumns_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetColumns failed: unknown result";
}
sub GetFunctions{
  my $self = shift;
  my $req = shift;

    $self->send_GetFunctions($req);
  return $self->recv_GetFunctions();
}

sub send_GetFunctions{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetFunctions', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetFunctions_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetFunctions{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetFunctions_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetFunctions failed: unknown result";
}
sub GetOperationStatus{
  my $self = shift;
  my $req = shift;

    $self->send_GetOperationStatus($req);
  return $self->recv_GetOperationStatus();
}

sub send_GetOperationStatus{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetOperationStatus', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetOperationStatus_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetOperationStatus{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetOperationStatus_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetOperationStatus failed: unknown result";
}
sub CancelOperation{
  my $self = shift;
  my $req = shift;

    $self->send_CancelOperation($req);
  return $self->recv_CancelOperation();
}

sub send_CancelOperation{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('CancelOperation', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_CancelOperation_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_CancelOperation{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_CancelOperation_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "CancelOperation failed: unknown result";
}
sub CloseOperation{
  my $self = shift;
  my $req = shift;

    $self->send_CloseOperation($req);
  return $self->recv_CloseOperation();
}

sub send_CloseOperation{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('CloseOperation', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_CloseOperation_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_CloseOperation{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_CloseOperation_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "CloseOperation failed: unknown result";
}
sub GetResultSetMetadata{
  my $self = shift;
  my $req = shift;

    $self->send_GetResultSetMetadata($req);
  return $self->recv_GetResultSetMetadata();
}

sub send_GetResultSetMetadata{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('GetResultSetMetadata', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_GetResultSetMetadata{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "GetResultSetMetadata failed: unknown result";
}
sub FetchResults{
  my $self = shift;
  my $req = shift;

    $self->send_FetchResults($req);
  return $self->recv_FetchResults();
}

sub send_FetchResults{
  my $self = shift;
  my $req = shift;

  $self->{output}->writeMessageBegin('FetchResults', TMessageType::CALL, $self->{seqid});
  my $args = new Thrift::API::HiveClient2::TCLIService_FetchResults_args();
  $args->{req} = $req;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_FetchResults{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = new TApplicationException();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = new Thrift::API::HiveClient2::TCLIService_FetchResults_result();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "FetchResults failed: unknown result";
}
package Thrift::API::HiveClient2::TCLIServiceProcessor;
$Thrift::API::HiveClient2::TCLIServiceProcessor::VERSION = '0.024';
{
  $Thrift::API::HiveClient2::TCLIServiceProcessor::DIST = 'Thrift-API-HiveClient2';
}

use strict;


sub new {
    my ($classname, $handler) = @_;
    my $self      = {};
    $self->{handler} = $handler;
    return bless ($self, $classname);
}

sub process {
    my ($self, $input, $output) = @_;
    my $rseqid = 0;
    my $fname  = undef;
    my $mtype  = 0;

    $input->readMessageBegin(\$fname, \$mtype, \$rseqid);
    my $methodname = 'process_'.$fname;
    if (!$self->can($methodname)) {
      $input->skip(TType::STRUCT);
      $input->readMessageEnd();
      my $x = new TApplicationException('Function '.$fname.' not implemented.', TApplicationException::UNKNOWN_METHOD);
      $output->writeMessageBegin($fname, TMessageType::EXCEPTION, $rseqid);
      $x->write($output);
      $output->writeMessageEnd();
      $output->getTransport()->flush();
      return;
    }
    $self->$methodname($rseqid, $input, $output);
    return 1;
}

sub process_OpenSession {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_OpenSession_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_OpenSession_result();
    $result->{success} = $self->{handler}->OpenSession($args->req);
    $output->writeMessageBegin('OpenSession', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_CloseSession {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_CloseSession_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_CloseSession_result();
    $result->{success} = $self->{handler}->CloseSession($args->req);
    $output->writeMessageBegin('CloseSession', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetInfo {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetInfo_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetInfo_result();
    $result->{success} = $self->{handler}->GetInfo($args->req);
    $output->writeMessageBegin('GetInfo', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_ExecuteStatement {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_ExecuteStatement_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_ExecuteStatement_result();
    $result->{success} = $self->{handler}->ExecuteStatement($args->req);
    $output->writeMessageBegin('ExecuteStatement', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetTypeInfo {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetTypeInfo_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetTypeInfo_result();
    $result->{success} = $self->{handler}->GetTypeInfo($args->req);
    $output->writeMessageBegin('GetTypeInfo', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetCatalogs {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetCatalogs_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetCatalogs_result();
    $result->{success} = $self->{handler}->GetCatalogs($args->req);
    $output->writeMessageBegin('GetCatalogs', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetSchemas {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetSchemas_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetSchemas_result();
    $result->{success} = $self->{handler}->GetSchemas($args->req);
    $output->writeMessageBegin('GetSchemas', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetTables {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetTables_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetTables_result();
    $result->{success} = $self->{handler}->GetTables($args->req);
    $output->writeMessageBegin('GetTables', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetTableTypes {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetTableTypes_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetTableTypes_result();
    $result->{success} = $self->{handler}->GetTableTypes($args->req);
    $output->writeMessageBegin('GetTableTypes', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetColumns {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetColumns_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetColumns_result();
    $result->{success} = $self->{handler}->GetColumns($args->req);
    $output->writeMessageBegin('GetColumns', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetFunctions {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetFunctions_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetFunctions_result();
    $result->{success} = $self->{handler}->GetFunctions($args->req);
    $output->writeMessageBegin('GetFunctions', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetOperationStatus {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetOperationStatus_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetOperationStatus_result();
    $result->{success} = $self->{handler}->GetOperationStatus($args->req);
    $output->writeMessageBegin('GetOperationStatus', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_CancelOperation {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_CancelOperation_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_CancelOperation_result();
    $result->{success} = $self->{handler}->CancelOperation($args->req);
    $output->writeMessageBegin('CancelOperation', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_CloseOperation {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_CloseOperation_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_CloseOperation_result();
    $result->{success} = $self->{handler}->CloseOperation($args->req);
    $output->writeMessageBegin('CloseOperation', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_GetResultSetMetadata {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_GetResultSetMetadata_result();
    $result->{success} = $self->{handler}->GetResultSetMetadata($args->req);
    $output->writeMessageBegin('GetResultSetMetadata', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_FetchResults {
    my ($self, $seqid, $input, $output) = @_;
    my $args = new Thrift::API::HiveClient2::TCLIService_FetchResults_args();
    $args->read($input);
    $input->readMessageEnd();
    my $result = new Thrift::API::HiveClient2::TCLIService_FetchResults_result();
    $result->{success} = $self->{handler}->FetchResults($args->req);
    $output->writeMessageBegin('FetchResults', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

1;

__END__

=pod

=encoding UTF-8

=head1 NAME

Thrift::API::HiveClient2::TCLIService_OpenSession_args

=head1 VERSION

version 0.024

=head1 AUTHOR

David Morel <david.morel@amakuru.net>

=head1 COPYRIGHT AND LICENSE

This software is Copyright (c) 2015 by David Morel & Booking.com. Portions are (c) R.Scaffidi, Thrift files are (c) Apache Software Foundation.

This is free software, licensed under:

  The Apache License, Version 2.0, January 2004

=cut