rpc

package
v2.0.3-1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 20, 2025 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var GoUnusedProtection__ int
View Source 
var IClientRPCServiceAppendSchemaTemplateResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceCancelOperationResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceCloseOperationResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceCloseSessionResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceCreateAlignedTimeseriesResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceCreateMultiTimeseriesResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceCreateSchemaTemplateResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceCreateTimeseriesResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceDeleteDataResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceDeleteStorageGroupsResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceDeleteTimeseriesResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceDropSchemaTemplateResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceExecuteBatchStatementResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceHandshakeResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceInsertRecordResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceInsertRecordsOfOneDeviceResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceInsertRecordsResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceInsertStringRecordResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceInsertStringRecordsOfOneDeviceResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceInsertStringRecordsResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceInsertTabletResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceInsertTabletsResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServicePruneSchemaTemplateResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceRequestStatementIdResult_Success_DEFAULT int64
View Source 
var IClientRPCServiceSendFileResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceSendPipeDataResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceSetSchemaTemplateResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceSetStorageGroupResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceSetTimeZoneResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceShowConfigurationResult_Success_DEFAULT *common.TShowConfigurationResp
View Source 
var IClientRPCServiceShowConfigurationTemplateResult_Success_DEFAULT *common.TShowConfigurationTemplateResp
View Source 
var IClientRPCServiceTestConnectionEmptyRPCResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceTestInsertRecordResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceTestInsertRecordsOfOneDeviceResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceTestInsertRecordsResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceTestInsertStringRecordResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceTestInsertStringRecordsResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceTestInsertTabletResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceTestInsertTabletsResult_Success_DEFAULT *common.TSStatus
View Source 
var IClientRPCServiceUnsetSchemaTemplateResult_Success_DEFAULT *common.TSStatus
View Source 
var ServerProperties_BuildInfo_DEFAULT string
View Source 
var ServerProperties_IsReadOnly_DEFAULT bool
View Source 
var ServerProperties_Logo_DEFAULT string
View Source 
var ServerProperties_ThriftMaxFrameSize_DEFAULT int32
View Source 
var TPipeSubscribeReq_Body_DEFAULT []byte
View Source 
var TPipeSubscribeResp_Body_DEFAULT [][]byte
View Source 
var TPipeSubscribeResp_Status_DEFAULT *common.TSStatus
View Source 
var TPipeTransferResp_Body_DEFAULT []byte
View Source 
var TPipeTransferResp_Status_DEFAULT *common.TSStatus
View Source 
var TSAggregationQueryReq_EndTime_DEFAULT int64
View Source 
var TSAggregationQueryReq_FetchSize_DEFAULT int32
View Source 
var TSAggregationQueryReq_Interval_DEFAULT int64
View Source 
var TSAggregationQueryReq_LegalPathNodes_DEFAULT bool
View Source 
var TSAggregationQueryReq_SlidingStep_DEFAULT int64
View Source 
var TSAggregationQueryReq_StartTime_DEFAULT int64
View Source 
var TSAggregationQueryReq_Timeout_DEFAULT int64
View Source 
var TSBackupConfigurationResp_EnableOperationSync_DEFAULT bool
View Source 
var TSBackupConfigurationResp_SecondaryAddress_DEFAULT string
View Source 
var TSBackupConfigurationResp_SecondaryPort_DEFAULT int32
View Source 
var TSBackupConfigurationResp_Status_DEFAULT *common.TSStatus
View Source 
var TSCloseOperationReq_QueryId_DEFAULT int64
View Source 
var TSCloseOperationReq_StatementId_DEFAULT int64
View Source 
var TSCreateAlignedTimeseriesReq_AttributesList_DEFAULT []map[string]string
View Source 
var TSCreateAlignedTimeseriesReq_MeasurementAlias_DEFAULT []string
View Source 
var TSCreateAlignedTimeseriesReq_TagsList_DEFAULT []map[string]string
View Source 
var TSCreateMultiTimeseriesReq_AttributesList_DEFAULT []map[string]string
View Source 
var TSCreateMultiTimeseriesReq_MeasurementAliasList_DEFAULT []string
View Source 
var TSCreateMultiTimeseriesReq_PropsList_DEFAULT []map[string]string
View Source 
var TSCreateMultiTimeseriesReq_TagsList_DEFAULT []map[string]string
View Source 
var TSCreateTimeseriesReq_Attributes_DEFAULT map[string]string
View Source 
var TSCreateTimeseriesReq_MeasurementAlias_DEFAULT string
View Source 
var TSCreateTimeseriesReq_Props_DEFAULT map[string]string
View Source 
var TSCreateTimeseriesReq_Tags_DEFAULT map[string]string
View Source 
var TSExecuteStatementReq_EnableRedirectQuery_DEFAULT bool
View Source 
var TSExecuteStatementReq_FetchSize_DEFAULT int32
View Source 
var TSExecuteStatementReq_JdbcQuery_DEFAULT bool
View Source 
var TSExecuteStatementReq_Timeout_DEFAULT int64
View Source 
var TSExecuteStatementResp_AliasColumns_DEFAULT []int8
View Source 
var TSExecuteStatementResp_ColumnIndex2TsBlockColumnIndexList_DEFAULT []int32
View Source 
var TSExecuteStatementResp_ColumnNameIndexMap_DEFAULT map[string]int32
View Source 
var TSExecuteStatementResp_Columns_DEFAULT []string
View Source 
var TSExecuteStatementResp_DataTypeList_DEFAULT []string
View Source 
var TSExecuteStatementResp_Database_DEFAULT string
View Source 
var TSExecuteStatementResp_IgnoreTimeStamp_DEFAULT bool
View Source 
var TSExecuteStatementResp_MoreData_DEFAULT bool
View Source 
var TSExecuteStatementResp_OperationType_DEFAULT string
View Source 
var TSExecuteStatementResp_QueryId_DEFAULT int64
View Source 
var TSExecuteStatementResp_QueryResult__DEFAULT [][]byte
View Source 
var TSExecuteStatementResp_SgColumns_DEFAULT []string
View Source 
var TSExecuteStatementResp_Status_DEFAULT *common.TSStatus
View Source 
var TSExecuteStatementResp_TableModel_DEFAULT bool
View Source 
var TSFastLastDataQueryForOneDeviceReq_EnableRedirectQuery_DEFAULT bool
View Source 
var TSFastLastDataQueryForOneDeviceReq_FetchSize_DEFAULT int32
View Source 
var TSFastLastDataQueryForOneDeviceReq_JdbcQuery_DEFAULT bool
View Source 
var TSFastLastDataQueryForOneDeviceReq_LegalPathNodes_DEFAULT bool
View Source 
var TSFastLastDataQueryForOneDeviceReq_Timeout_DEFAULT int64
View Source 
var TSFastLastDataQueryForOnePrefixPathReq_EnableRedirectQuery_DEFAULT bool
View Source 
var TSFastLastDataQueryForOnePrefixPathReq_FetchSize_DEFAULT int32
View Source 
var TSFastLastDataQueryForOnePrefixPathReq_JdbcQuery_DEFAULT bool
View Source 
var TSFastLastDataQueryForOnePrefixPathReq_Timeout_DEFAULT int64
View Source 
var TSFetchMetadataReq_ColumnPath_DEFAULT string
View Source 
var TSFetchMetadataResp_ColumnsList_DEFAULT []string
View Source 
var TSFetchMetadataResp_DataType_DEFAULT string
View Source 
var TSFetchMetadataResp_MetadataInJson_DEFAULT string
View Source 
var TSFetchMetadataResp_Status_DEFAULT *common.TSStatus
View Source 
var TSFetchResultsReq_StatementId_DEFAULT int64
View Source 
var TSFetchResultsReq_Timeout_DEFAULT int64
View Source 
var TSFetchResultsResp_MoreData_DEFAULT bool
View Source 
var TSFetchResultsResp_QueryResult__DEFAULT [][]byte
View Source 
var TSFetchResultsResp_Status_DEFAULT *common.TSStatus
View Source 
var TSGetTimeZoneResp_Status_DEFAULT *common.TSStatus
View Source 
var TSGroupByQueryIntervalReq_Database_DEFAULT string
View Source 
var TSGroupByQueryIntervalReq_EndTime_DEFAULT int64
View Source 
var TSGroupByQueryIntervalReq_FetchSize_DEFAULT int32
View Source 
var TSGroupByQueryIntervalReq_Interval_DEFAULT int64
View Source 
var TSGroupByQueryIntervalReq_IsAligned_DEFAULT bool
View Source 
var TSGroupByQueryIntervalReq_StartTime_DEFAULT int64
View Source 
var TSGroupByQueryIntervalReq_Timeout_DEFAULT int64
View Source 
var TSInsertRecordReq_ColumnCategoryies_DEFAULT []int8
View Source 
var TSInsertRecordReq_IsAligned_DEFAULT bool
View Source 
var TSInsertRecordReq_IsWriteToTable_DEFAULT bool
View Source 
var TSInsertRecordsOfOneDeviceReq_IsAligned_DEFAULT bool
View Source 
var TSInsertRecordsReq_IsAligned_DEFAULT bool
View Source 
var TSInsertStringRecordReq_IsAligned_DEFAULT bool
View Source 
var TSInsertStringRecordReq_Timeout_DEFAULT int64
View Source 
var TSInsertStringRecordsOfOneDeviceReq_IsAligned_DEFAULT bool
View Source 
var TSInsertStringRecordsReq_IsAligned_DEFAULT bool
View Source 
var TSInsertTabletReq_ColumnCategories_DEFAULT []int8
View Source 
var TSInsertTabletReq_IsAligned_DEFAULT bool
View Source 
var TSInsertTabletReq_WriteToTable_DEFAULT bool
View Source 
var TSInsertTabletsReq_IsAligned_DEFAULT bool
View Source 
var TSLastDataQueryReq_EnableRedirectQuery_DEFAULT bool
View Source 
var TSLastDataQueryReq_FetchSize_DEFAULT int32
View Source 
var TSLastDataQueryReq_JdbcQuery_DEFAULT bool
View Source 
var TSLastDataQueryReq_LegalPathNodes_DEFAULT bool
View Source 
var TSLastDataQueryReq_Timeout_DEFAULT int64
View Source 
var TSOpenSessionReq_Configuration_DEFAULT map[string]string
View Source 
var TSOpenSessionReq_Password_DEFAULT string
View Source 
var TSOpenSessionResp_Configuration_DEFAULT map[string]string
View Source 
var TSOpenSessionResp_SessionId_DEFAULT int64
View Source 
var TSOpenSessionResp_Status_DEFAULT *common.TSStatus
View Source 
var TSQueryTemplateReq_Measurement_DEFAULT string
View Source 
var TSQueryTemplateResp_Count_DEFAULT int32
View Source 
var TSQueryTemplateResp_Measurements_DEFAULT []string
View Source 
var TSQueryTemplateResp_Result__DEFAULT bool
View Source 
var TSQueryTemplateResp_Status_DEFAULT *common.TSStatus
View Source 
var TSRawDataQueryReq_EnableRedirectQuery_DEFAULT bool
View Source 
var TSRawDataQueryReq_FetchSize_DEFAULT int32
View Source 
var TSRawDataQueryReq_JdbcQuery_DEFAULT bool
View Source 
var TSRawDataQueryReq_LegalPathNodes_DEFAULT bool
View Source 
var TSRawDataQueryReq_Timeout_DEFAULT int64
View Source 
var TSTracingInfo_OverlappedPageNum_DEFAULT int32
View Source 
var TSTracingInfo_SeqFileNum_DEFAULT int32
View Source 
var TSTracingInfo_SequenceChunkNum_DEFAULT int32
View Source 
var TSTracingInfo_SequenceChunkPointNum_DEFAULT int64
View Source 
var TSTracingInfo_SeriesPathNum_DEFAULT int32
View Source 
var TSTracingInfo_TotalPageNum_DEFAULT int32
View Source 
var TSTracingInfo_UnSeqFileNum_DEFAULT int32
View Source 
var TSTracingInfo_UnsequenceChunkNum_DEFAULT int32
View Source 
var TSTracingInfo_UnsequenceChunkPointNum_DEFAULT int64

Functions

This section is empty.

Types

type IClientRPCService 

type IClientRPCService interface {
	// Parameters:
	//  - Req
	ExecuteQueryStatementV2(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteUpdateStatementV2(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteStatementV2(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteRawDataQueryV2(ctx context.Context, req *TSRawDataQueryReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteLastDataQueryV2(ctx context.Context, req *TSLastDataQueryReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteFastLastDataQueryForOnePrefixPath(ctx context.Context, req *TSFastLastDataQueryForOnePrefixPathReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteFastLastDataQueryForOneDeviceV2(ctx context.Context, req *TSFastLastDataQueryForOneDeviceReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteAggregationQueryV2(ctx context.Context, req *TSAggregationQueryReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteGroupByQueryIntervalQuery(ctx context.Context, req *TSGroupByQueryIntervalReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	FetchResultsV2(ctx context.Context, req *TSFetchResultsReq) (_r *TSFetchResultsResp, _err error)
	// Parameters:
	//  - Req
	OpenSession(ctx context.Context, req *TSOpenSessionReq) (_r *TSOpenSessionResp, _err error)
	// Parameters:
	//  - Req
	CloseSession(ctx context.Context, req *TSCloseSessionReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	ExecuteStatement(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteBatchStatement(ctx context.Context, req *TSExecuteBatchStatementReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	ExecuteQueryStatement(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteUpdateStatement(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	FetchResults(ctx context.Context, req *TSFetchResultsReq) (_r *TSFetchResultsResp, _err error)
	// Parameters:
	//  - Req
	FetchMetadata(ctx context.Context, req *TSFetchMetadataReq) (_r *TSFetchMetadataResp, _err error)
	// Parameters:
	//  - Req
	CancelOperation(ctx context.Context, req *TSCancelOperationReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	CloseOperation(ctx context.Context, req *TSCloseOperationReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - SessionId
	GetTimeZone(ctx context.Context, sessionId int64) (_r *TSGetTimeZoneResp, _err error)
	// Parameters:
	//  - Req
	SetTimeZone(ctx context.Context, req *TSSetTimeZoneReq) (_r *common.TSStatus, _err error)
	GetProperties(ctx context.Context) (_r *ServerProperties, _err error)
	// Parameters:
	//  - SessionId
	//  - StorageGroup
	SetStorageGroup(ctx context.Context, sessionId int64, storageGroup string) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	CreateTimeseries(ctx context.Context, req *TSCreateTimeseriesReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	CreateAlignedTimeseries(ctx context.Context, req *TSCreateAlignedTimeseriesReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	CreateMultiTimeseries(ctx context.Context, req *TSCreateMultiTimeseriesReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - SessionId
	//  - Path
	DeleteTimeseries(ctx context.Context, sessionId int64, path []string) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - SessionId
	//  - StorageGroup
	DeleteStorageGroups(ctx context.Context, sessionId int64, storageGroup []string) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	InsertRecord(ctx context.Context, req *TSInsertRecordReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	InsertStringRecord(ctx context.Context, req *TSInsertStringRecordReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	InsertTablet(ctx context.Context, req *TSInsertTabletReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	InsertTablets(ctx context.Context, req *TSInsertTabletsReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	InsertRecords(ctx context.Context, req *TSInsertRecordsReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	InsertRecordsOfOneDevice(ctx context.Context, req *TSInsertRecordsOfOneDeviceReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	InsertStringRecordsOfOneDevice(ctx context.Context, req *TSInsertStringRecordsOfOneDeviceReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	InsertStringRecords(ctx context.Context, req *TSInsertStringRecordsReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	TestInsertTablet(ctx context.Context, req *TSInsertTabletReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	TestInsertTablets(ctx context.Context, req *TSInsertTabletsReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	TestInsertRecord(ctx context.Context, req *TSInsertRecordReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	TestInsertStringRecord(ctx context.Context, req *TSInsertStringRecordReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	TestInsertRecords(ctx context.Context, req *TSInsertRecordsReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	TestInsertRecordsOfOneDevice(ctx context.Context, req *TSInsertRecordsOfOneDeviceReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	TestInsertStringRecords(ctx context.Context, req *TSInsertStringRecordsReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	DeleteData(ctx context.Context, req *TSDeleteDataReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	ExecuteRawDataQuery(ctx context.Context, req *TSRawDataQueryReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteLastDataQuery(ctx context.Context, req *TSLastDataQueryReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - Req
	ExecuteAggregationQuery(ctx context.Context, req *TSAggregationQueryReq) (_r *TSExecuteStatementResp, _err error)
	// Parameters:
	//  - SessionId
	RequestStatementId(ctx context.Context, sessionId int64) (_r int64, _err error)
	// Parameters:
	//  - Req
	CreateSchemaTemplate(ctx context.Context, req *TSCreateSchemaTemplateReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	AppendSchemaTemplate(ctx context.Context, req *TSAppendSchemaTemplateReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	PruneSchemaTemplate(ctx context.Context, req *TSPruneSchemaTemplateReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	QuerySchemaTemplate(ctx context.Context, req *TSQueryTemplateReq) (_r *TSQueryTemplateResp, _err error)
	ShowConfigurationTemplate(ctx context.Context) (_r *common.TShowConfigurationTemplateResp, _err error)
	// Parameters:
	//  - NodeId
	ShowConfiguration(ctx context.Context, nodeId int32) (_r *common.TShowConfigurationResp, _err error)
	// Parameters:
	//  - Req
	SetSchemaTemplate(ctx context.Context, req *TSSetSchemaTemplateReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	UnsetSchemaTemplate(ctx context.Context, req *TSUnsetSchemaTemplateReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	DropSchemaTemplate(ctx context.Context, req *TSDropSchemaTemplateReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	CreateTimeseriesUsingSchemaTemplate(ctx context.Context, req *TCreateTimeseriesUsingSchemaTemplateReq) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Info
	Handshake(ctx context.Context, info *TSyncIdentityInfo) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Buff
	SendPipeData(ctx context.Context, buff []byte) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - MetaInfo
	//  - Buff
	SendFile(ctx context.Context, metaInfo *TSyncTransportMetaInfo, buff []byte) (_r *common.TSStatus, _err error)
	// Parameters:
	//  - Req
	PipeTransfer(ctx context.Context, req *TPipeTransferReq) (_r *TPipeTransferResp, _err error)
	// Parameters:
	//  - Req
	PipeSubscribe(ctx context.Context, req *TPipeSubscribeReq) (_r *TPipeSubscribeResp, _err error)
	GetBackupConfiguration(ctx context.Context) (_r *TSBackupConfigurationResp, _err error)
	FetchAllConnectionsInfo(ctx context.Context) (_r *TSConnectionInfoResp, _err error)
	// For other node's call
	TestConnectionEmptyRPC(ctx context.Context) (_r *common.TSStatus, _err error)
}

type IClientRPCServiceAppendSchemaTemplateArgs 

type IClientRPCServiceAppendSchemaTemplateArgs struct {
	Req *TSAppendSchemaTemplateReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceAppendSchemaTemplateArgs 

func NewIClientRPCServiceAppendSchemaTemplateArgs() *IClientRPCServiceAppendSchemaTemplateArgs

func (*IClientRPCServiceAppendSchemaTemplateArgs) GetReq 

func (p *IClientRPCServiceAppendSchemaTemplateArgs) GetReq() *TSAppendSchemaTemplateReq

func (*IClientRPCServiceAppendSchemaTemplateArgs) IsSetReq 

func (p *IClientRPCServiceAppendSchemaTemplateArgs) IsSetReq() bool

func (*IClientRPCServiceAppendSchemaTemplateArgs) Read 

func (p *IClientRPCServiceAppendSchemaTemplateArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceAppendSchemaTemplateArgs) ReadField1 

func (p *IClientRPCServiceAppendSchemaTemplateArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceAppendSchemaTemplateArgs) String 

func (p *IClientRPCServiceAppendSchemaTemplateArgs) String() string

func (*IClientRPCServiceAppendSchemaTemplateArgs) Write 

func (p *IClientRPCServiceAppendSchemaTemplateArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceAppendSchemaTemplateResult 

type IClientRPCServiceAppendSchemaTemplateResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceAppendSchemaTemplateResult 

func NewIClientRPCServiceAppendSchemaTemplateResult() *IClientRPCServiceAppendSchemaTemplateResult

func (*IClientRPCServiceAppendSchemaTemplateResult) GetSuccess 

func (p *IClientRPCServiceAppendSchemaTemplateResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceAppendSchemaTemplateResult) IsSetSuccess 

func (p *IClientRPCServiceAppendSchemaTemplateResult) IsSetSuccess() bool

func (*IClientRPCServiceAppendSchemaTemplateResult) Read 

func (p *IClientRPCServiceAppendSchemaTemplateResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceAppendSchemaTemplateResult) ReadField0 

func (p *IClientRPCServiceAppendSchemaTemplateResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceAppendSchemaTemplateResult) String 

func (p *IClientRPCServiceAppendSchemaTemplateResult) String() string

func (*IClientRPCServiceAppendSchemaTemplateResult) Write 

func (p *IClientRPCServiceAppendSchemaTemplateResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCancelOperationArgs 

type IClientRPCServiceCancelOperationArgs struct {
	Req *TSCancelOperationReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceCancelOperationArgs 

func NewIClientRPCServiceCancelOperationArgs() *IClientRPCServiceCancelOperationArgs

func (*IClientRPCServiceCancelOperationArgs) GetReq 

func (p *IClientRPCServiceCancelOperationArgs) GetReq() *TSCancelOperationReq

func (*IClientRPCServiceCancelOperationArgs) IsSetReq 

func (p *IClientRPCServiceCancelOperationArgs) IsSetReq() bool

func (*IClientRPCServiceCancelOperationArgs) Read 

func (p *IClientRPCServiceCancelOperationArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCancelOperationArgs) ReadField1 

func (p *IClientRPCServiceCancelOperationArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCancelOperationArgs) String 

func (p *IClientRPCServiceCancelOperationArgs) String() string

func (*IClientRPCServiceCancelOperationArgs) Write 

func (p *IClientRPCServiceCancelOperationArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCancelOperationResult 

type IClientRPCServiceCancelOperationResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceCancelOperationResult 

func NewIClientRPCServiceCancelOperationResult() *IClientRPCServiceCancelOperationResult

func (*IClientRPCServiceCancelOperationResult) GetSuccess 

func (p *IClientRPCServiceCancelOperationResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceCancelOperationResult) IsSetSuccess 

func (p *IClientRPCServiceCancelOperationResult) IsSetSuccess() bool

func (*IClientRPCServiceCancelOperationResult) Read 

func (p *IClientRPCServiceCancelOperationResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCancelOperationResult) ReadField0 

func (p *IClientRPCServiceCancelOperationResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCancelOperationResult) String 

func (p *IClientRPCServiceCancelOperationResult) String() string

func (*IClientRPCServiceCancelOperationResult) Write 

func (p *IClientRPCServiceCancelOperationResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceClient 

type IClientRPCServiceClient struct {
	// contains filtered or unexported fields
}

func NewIClientRPCServiceClient 

func NewIClientRPCServiceClient(c thrift.TClient) *IClientRPCServiceClient

func NewIClientRPCServiceClientFactory 

func NewIClientRPCServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *IClientRPCServiceClient

func NewIClientRPCServiceClientProtocol 

func NewIClientRPCServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *IClientRPCServiceClient

func (*IClientRPCServiceClient) AppendSchemaTemplate 

func (p *IClientRPCServiceClient) AppendSchemaTemplate(ctx context.Context, req *TSAppendSchemaTemplateReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) CancelOperation 

func (p *IClientRPCServiceClient) CancelOperation(ctx context.Context, req *TSCancelOperationReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) Client_ 

func (p *IClientRPCServiceClient) Client_() thrift.TClient

func (*IClientRPCServiceClient) CloseOperation 

func (p *IClientRPCServiceClient) CloseOperation(ctx context.Context, req *TSCloseOperationReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) CloseSession 

func (p *IClientRPCServiceClient) CloseSession(ctx context.Context, req *TSCloseSessionReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) CreateAlignedTimeseries 

func (p *IClientRPCServiceClient) CreateAlignedTimeseries(ctx context.Context, req *TSCreateAlignedTimeseriesReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) CreateMultiTimeseries 

func (p *IClientRPCServiceClient) CreateMultiTimeseries(ctx context.Context, req *TSCreateMultiTimeseriesReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) CreateSchemaTemplate 

func (p *IClientRPCServiceClient) CreateSchemaTemplate(ctx context.Context, req *TSCreateSchemaTemplateReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) CreateTimeseries 

func (p *IClientRPCServiceClient) CreateTimeseries(ctx context.Context, req *TSCreateTimeseriesReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) CreateTimeseriesUsingSchemaTemplate 

func (p *IClientRPCServiceClient) CreateTimeseriesUsingSchemaTemplate(ctx context.Context, req *TCreateTimeseriesUsingSchemaTemplateReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) DeleteData 

func (p *IClientRPCServiceClient) DeleteData(ctx context.Context, req *TSDeleteDataReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) DeleteStorageGroups 

func (p *IClientRPCServiceClient) DeleteStorageGroups(ctx context.Context, sessionId int64, storageGroup []string) (_r *common.TSStatus, _err error)

Parameters:

  • SessionId
  • StorageGroup

func (*IClientRPCServiceClient) DeleteTimeseries 

func (p *IClientRPCServiceClient) DeleteTimeseries(ctx context.Context, sessionId int64, path []string) (_r *common.TSStatus, _err error)

Parameters:

  • SessionId
  • Path

func (*IClientRPCServiceClient) DropSchemaTemplate 

func (p *IClientRPCServiceClient) DropSchemaTemplate(ctx context.Context, req *TSDropSchemaTemplateReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteAggregationQuery 

func (p *IClientRPCServiceClient) ExecuteAggregationQuery(ctx context.Context, req *TSAggregationQueryReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteAggregationQueryV2 

func (p *IClientRPCServiceClient) ExecuteAggregationQueryV2(ctx context.Context, req *TSAggregationQueryReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteBatchStatement 

func (p *IClientRPCServiceClient) ExecuteBatchStatement(ctx context.Context, req *TSExecuteBatchStatementReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteFastLastDataQueryForOneDeviceV2 

func (p *IClientRPCServiceClient) ExecuteFastLastDataQueryForOneDeviceV2(ctx context.Context, req *TSFastLastDataQueryForOneDeviceReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteFastLastDataQueryForOnePrefixPath 

func (p *IClientRPCServiceClient) ExecuteFastLastDataQueryForOnePrefixPath(ctx context.Context, req *TSFastLastDataQueryForOnePrefixPathReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteGroupByQueryIntervalQuery 

func (p *IClientRPCServiceClient) ExecuteGroupByQueryIntervalQuery(ctx context.Context, req *TSGroupByQueryIntervalReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteLastDataQuery 

func (p *IClientRPCServiceClient) ExecuteLastDataQuery(ctx context.Context, req *TSLastDataQueryReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteLastDataQueryV2 

func (p *IClientRPCServiceClient) ExecuteLastDataQueryV2(ctx context.Context, req *TSLastDataQueryReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteQueryStatement 

func (p *IClientRPCServiceClient) ExecuteQueryStatement(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteQueryStatementV2 

func (p *IClientRPCServiceClient) ExecuteQueryStatementV2(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteRawDataQuery 

func (p *IClientRPCServiceClient) ExecuteRawDataQuery(ctx context.Context, req *TSRawDataQueryReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteRawDataQueryV2 

func (p *IClientRPCServiceClient) ExecuteRawDataQueryV2(ctx context.Context, req *TSRawDataQueryReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteStatement 

func (p *IClientRPCServiceClient) ExecuteStatement(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteStatementV2 

func (p *IClientRPCServiceClient) ExecuteStatementV2(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteUpdateStatement 

func (p *IClientRPCServiceClient) ExecuteUpdateStatement(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ExecuteUpdateStatementV2 

func (p *IClientRPCServiceClient) ExecuteUpdateStatementV2(ctx context.Context, req *TSExecuteStatementReq) (_r *TSExecuteStatementResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) FetchAllConnectionsInfo 

func (p *IClientRPCServiceClient) FetchAllConnectionsInfo(ctx context.Context) (_r *TSConnectionInfoResp, _err error)

func (*IClientRPCServiceClient) FetchMetadata 

func (p *IClientRPCServiceClient) FetchMetadata(ctx context.Context, req *TSFetchMetadataReq) (_r *TSFetchMetadataResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) FetchResults 

func (p *IClientRPCServiceClient) FetchResults(ctx context.Context, req *TSFetchResultsReq) (_r *TSFetchResultsResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) FetchResultsV2 

func (p *IClientRPCServiceClient) FetchResultsV2(ctx context.Context, req *TSFetchResultsReq) (_r *TSFetchResultsResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) GetBackupConfiguration 

func (p *IClientRPCServiceClient) GetBackupConfiguration(ctx context.Context) (_r *TSBackupConfigurationResp, _err error)

func (*IClientRPCServiceClient) GetProperties 

func (p *IClientRPCServiceClient) GetProperties(ctx context.Context) (_r *ServerProperties, _err error)

func (*IClientRPCServiceClient) GetTimeZone 

func (p *IClientRPCServiceClient) GetTimeZone(ctx context.Context, sessionId int64) (_r *TSGetTimeZoneResp, _err error)

Parameters:

  • SessionId

func (*IClientRPCServiceClient) Handshake 

func (p *IClientRPCServiceClient) Handshake(ctx context.Context, info *TSyncIdentityInfo) (_r *common.TSStatus, _err error)

Parameters:

  • Info

func (*IClientRPCServiceClient) InsertRecord 

func (p *IClientRPCServiceClient) InsertRecord(ctx context.Context, req *TSInsertRecordReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) InsertRecords 

func (p *IClientRPCServiceClient) InsertRecords(ctx context.Context, req *TSInsertRecordsReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) InsertRecordsOfOneDevice 

func (p *IClientRPCServiceClient) InsertRecordsOfOneDevice(ctx context.Context, req *TSInsertRecordsOfOneDeviceReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) InsertStringRecord 

func (p *IClientRPCServiceClient) InsertStringRecord(ctx context.Context, req *TSInsertStringRecordReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) InsertStringRecords 

func (p *IClientRPCServiceClient) InsertStringRecords(ctx context.Context, req *TSInsertStringRecordsReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) InsertStringRecordsOfOneDevice 

func (p *IClientRPCServiceClient) InsertStringRecordsOfOneDevice(ctx context.Context, req *TSInsertStringRecordsOfOneDeviceReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) InsertTablet 

func (p *IClientRPCServiceClient) InsertTablet(ctx context.Context, req *TSInsertTabletReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) InsertTablets 

func (p *IClientRPCServiceClient) InsertTablets(ctx context.Context, req *TSInsertTabletsReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) LastResponseMeta_ 

func (p *IClientRPCServiceClient) LastResponseMeta_() thrift.ResponseMeta

func (*IClientRPCServiceClient) OpenSession 

func (p *IClientRPCServiceClient) OpenSession(ctx context.Context, req *TSOpenSessionReq) (_r *TSOpenSessionResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) PipeSubscribe 

func (p *IClientRPCServiceClient) PipeSubscribe(ctx context.Context, req *TPipeSubscribeReq) (_r *TPipeSubscribeResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) PipeTransfer 

func (p *IClientRPCServiceClient) PipeTransfer(ctx context.Context, req *TPipeTransferReq) (_r *TPipeTransferResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) PruneSchemaTemplate 

func (p *IClientRPCServiceClient) PruneSchemaTemplate(ctx context.Context, req *TSPruneSchemaTemplateReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) QuerySchemaTemplate 

func (p *IClientRPCServiceClient) QuerySchemaTemplate(ctx context.Context, req *TSQueryTemplateReq) (_r *TSQueryTemplateResp, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) RequestStatementId 

func (p *IClientRPCServiceClient) RequestStatementId(ctx context.Context, sessionId int64) (_r int64, _err error)

Parameters:

  • SessionId

func (*IClientRPCServiceClient) SendFile 

func (p *IClientRPCServiceClient) SendFile(ctx context.Context, metaInfo *TSyncTransportMetaInfo, buff []byte) (_r *common.TSStatus, _err error)

Parameters:

  • MetaInfo
  • Buff

func (*IClientRPCServiceClient) SendPipeData 

func (p *IClientRPCServiceClient) SendPipeData(ctx context.Context, buff []byte) (_r *common.TSStatus, _err error)

Parameters:

  • Buff

func (*IClientRPCServiceClient) SetLastResponseMeta_ 

func (p *IClientRPCServiceClient) SetLastResponseMeta_(meta thrift.ResponseMeta)

func (*IClientRPCServiceClient) SetSchemaTemplate 

func (p *IClientRPCServiceClient) SetSchemaTemplate(ctx context.Context, req *TSSetSchemaTemplateReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) SetStorageGroup 

func (p *IClientRPCServiceClient) SetStorageGroup(ctx context.Context, sessionId int64, storageGroup string) (_r *common.TSStatus, _err error)

Parameters:

  • SessionId
  • StorageGroup

func (*IClientRPCServiceClient) SetTimeZone 

func (p *IClientRPCServiceClient) SetTimeZone(ctx context.Context, req *TSSetTimeZoneReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) ShowConfiguration 

func (p *IClientRPCServiceClient) ShowConfiguration(ctx context.Context, nodeId int32) (_r *common.TShowConfigurationResp, _err error)

Parameters:

  • NodeId

func (*IClientRPCServiceClient) ShowConfigurationTemplate 

func (p *IClientRPCServiceClient) ShowConfigurationTemplate(ctx context.Context) (_r *common.TShowConfigurationTemplateResp, _err error)

func (*IClientRPCServiceClient) TestConnectionEmptyRPC 

func (p *IClientRPCServiceClient) TestConnectionEmptyRPC(ctx context.Context) (_r *common.TSStatus, _err error)

For other node's call

func (*IClientRPCServiceClient) TestInsertRecord 

func (p *IClientRPCServiceClient) TestInsertRecord(ctx context.Context, req *TSInsertRecordReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) TestInsertRecords 

func (p *IClientRPCServiceClient) TestInsertRecords(ctx context.Context, req *TSInsertRecordsReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) TestInsertRecordsOfOneDevice 

func (p *IClientRPCServiceClient) TestInsertRecordsOfOneDevice(ctx context.Context, req *TSInsertRecordsOfOneDeviceReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) TestInsertStringRecord 

func (p *IClientRPCServiceClient) TestInsertStringRecord(ctx context.Context, req *TSInsertStringRecordReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) TestInsertStringRecords 

func (p *IClientRPCServiceClient) TestInsertStringRecords(ctx context.Context, req *TSInsertStringRecordsReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) TestInsertTablet 

func (p *IClientRPCServiceClient) TestInsertTablet(ctx context.Context, req *TSInsertTabletReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) TestInsertTablets 

func (p *IClientRPCServiceClient) TestInsertTablets(ctx context.Context, req *TSInsertTabletsReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

func (*IClientRPCServiceClient) UnsetSchemaTemplate 

func (p *IClientRPCServiceClient) UnsetSchemaTemplate(ctx context.Context, req *TSUnsetSchemaTemplateReq) (_r *common.TSStatus, _err error)

Parameters:

  • Req

type IClientRPCServiceCloseOperationArgs 

type IClientRPCServiceCloseOperationArgs struct {
	Req *TSCloseOperationReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceCloseOperationArgs 

func NewIClientRPCServiceCloseOperationArgs() *IClientRPCServiceCloseOperationArgs

func (*IClientRPCServiceCloseOperationArgs) GetReq 

func (p *IClientRPCServiceCloseOperationArgs) GetReq() *TSCloseOperationReq

func (*IClientRPCServiceCloseOperationArgs) IsSetReq 

func (p *IClientRPCServiceCloseOperationArgs) IsSetReq() bool

func (*IClientRPCServiceCloseOperationArgs) Read 

func (p *IClientRPCServiceCloseOperationArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCloseOperationArgs) ReadField1 

func (p *IClientRPCServiceCloseOperationArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCloseOperationArgs) String 

func (p *IClientRPCServiceCloseOperationArgs) String() string

func (*IClientRPCServiceCloseOperationArgs) Write 

func (p *IClientRPCServiceCloseOperationArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCloseOperationResult 

type IClientRPCServiceCloseOperationResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceCloseOperationResult 

func NewIClientRPCServiceCloseOperationResult() *IClientRPCServiceCloseOperationResult

func (*IClientRPCServiceCloseOperationResult) GetSuccess 

func (p *IClientRPCServiceCloseOperationResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceCloseOperationResult) IsSetSuccess 

func (p *IClientRPCServiceCloseOperationResult) IsSetSuccess() bool

func (*IClientRPCServiceCloseOperationResult) Read 

func (p *IClientRPCServiceCloseOperationResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCloseOperationResult) ReadField0 

func (p *IClientRPCServiceCloseOperationResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCloseOperationResult) String 

func (p *IClientRPCServiceCloseOperationResult) String() string

func (*IClientRPCServiceCloseOperationResult) Write 

func (p *IClientRPCServiceCloseOperationResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCloseSessionArgs 

type IClientRPCServiceCloseSessionArgs struct {
	Req *TSCloseSessionReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceCloseSessionArgs 

func NewIClientRPCServiceCloseSessionArgs() *IClientRPCServiceCloseSessionArgs

func (*IClientRPCServiceCloseSessionArgs) GetReq 

func (p *IClientRPCServiceCloseSessionArgs) GetReq() *TSCloseSessionReq

func (*IClientRPCServiceCloseSessionArgs) IsSetReq 

func (p *IClientRPCServiceCloseSessionArgs) IsSetReq() bool

func (*IClientRPCServiceCloseSessionArgs) Read 

func (p *IClientRPCServiceCloseSessionArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCloseSessionArgs) ReadField1 

func (p *IClientRPCServiceCloseSessionArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCloseSessionArgs) String 

func (p *IClientRPCServiceCloseSessionArgs) String() string

func (*IClientRPCServiceCloseSessionArgs) Write 

func (p *IClientRPCServiceCloseSessionArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCloseSessionResult 

type IClientRPCServiceCloseSessionResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceCloseSessionResult 

func NewIClientRPCServiceCloseSessionResult() *IClientRPCServiceCloseSessionResult

func (*IClientRPCServiceCloseSessionResult) GetSuccess 

func (p *IClientRPCServiceCloseSessionResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceCloseSessionResult) IsSetSuccess 

func (p *IClientRPCServiceCloseSessionResult) IsSetSuccess() bool

func (*IClientRPCServiceCloseSessionResult) Read 

func (p *IClientRPCServiceCloseSessionResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCloseSessionResult) ReadField0 

func (p *IClientRPCServiceCloseSessionResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCloseSessionResult) String 

func (p *IClientRPCServiceCloseSessionResult) String() string

func (*IClientRPCServiceCloseSessionResult) Write 

func (p *IClientRPCServiceCloseSessionResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateAlignedTimeseriesArgs 

type IClientRPCServiceCreateAlignedTimeseriesArgs struct {
	Req *TSCreateAlignedTimeseriesReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceCreateAlignedTimeseriesArgs 

func NewIClientRPCServiceCreateAlignedTimeseriesArgs() *IClientRPCServiceCreateAlignedTimeseriesArgs

func (*IClientRPCServiceCreateAlignedTimeseriesArgs) GetReq 

func (p *IClientRPCServiceCreateAlignedTimeseriesArgs) GetReq() *TSCreateAlignedTimeseriesReq

func (*IClientRPCServiceCreateAlignedTimeseriesArgs) IsSetReq 

func (p *IClientRPCServiceCreateAlignedTimeseriesArgs) IsSetReq() bool

func (*IClientRPCServiceCreateAlignedTimeseriesArgs) Read 

func (p *IClientRPCServiceCreateAlignedTimeseriesArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateAlignedTimeseriesArgs) ReadField1 

func (p *IClientRPCServiceCreateAlignedTimeseriesArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateAlignedTimeseriesArgs) String 

func (p *IClientRPCServiceCreateAlignedTimeseriesArgs) String() string

func (*IClientRPCServiceCreateAlignedTimeseriesArgs) Write 

func (p *IClientRPCServiceCreateAlignedTimeseriesArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateAlignedTimeseriesResult 

type IClientRPCServiceCreateAlignedTimeseriesResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceCreateAlignedTimeseriesResult 

func NewIClientRPCServiceCreateAlignedTimeseriesResult() *IClientRPCServiceCreateAlignedTimeseriesResult

func (*IClientRPCServiceCreateAlignedTimeseriesResult) GetSuccess 

func (p *IClientRPCServiceCreateAlignedTimeseriesResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceCreateAlignedTimeseriesResult) IsSetSuccess 

func (p *IClientRPCServiceCreateAlignedTimeseriesResult) IsSetSuccess() bool

func (*IClientRPCServiceCreateAlignedTimeseriesResult) Read 

func (p *IClientRPCServiceCreateAlignedTimeseriesResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateAlignedTimeseriesResult) ReadField0 

func (p *IClientRPCServiceCreateAlignedTimeseriesResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateAlignedTimeseriesResult) String 

func (p *IClientRPCServiceCreateAlignedTimeseriesResult) String() string

func (*IClientRPCServiceCreateAlignedTimeseriesResult) Write 

func (p *IClientRPCServiceCreateAlignedTimeseriesResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateMultiTimeseriesArgs 

type IClientRPCServiceCreateMultiTimeseriesArgs struct {
	Req *TSCreateMultiTimeseriesReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceCreateMultiTimeseriesArgs 

func NewIClientRPCServiceCreateMultiTimeseriesArgs() *IClientRPCServiceCreateMultiTimeseriesArgs

func (*IClientRPCServiceCreateMultiTimeseriesArgs) GetReq 

func (p *IClientRPCServiceCreateMultiTimeseriesArgs) GetReq() *TSCreateMultiTimeseriesReq

func (*IClientRPCServiceCreateMultiTimeseriesArgs) IsSetReq 

func (p *IClientRPCServiceCreateMultiTimeseriesArgs) IsSetReq() bool

func (*IClientRPCServiceCreateMultiTimeseriesArgs) Read 

func (p *IClientRPCServiceCreateMultiTimeseriesArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateMultiTimeseriesArgs) ReadField1 

func (p *IClientRPCServiceCreateMultiTimeseriesArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateMultiTimeseriesArgs) String 

func (p *IClientRPCServiceCreateMultiTimeseriesArgs) String() string

func (*IClientRPCServiceCreateMultiTimeseriesArgs) Write 

func (p *IClientRPCServiceCreateMultiTimeseriesArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateMultiTimeseriesResult 

type IClientRPCServiceCreateMultiTimeseriesResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceCreateMultiTimeseriesResult 

func NewIClientRPCServiceCreateMultiTimeseriesResult() *IClientRPCServiceCreateMultiTimeseriesResult

func (*IClientRPCServiceCreateMultiTimeseriesResult) GetSuccess 

func (p *IClientRPCServiceCreateMultiTimeseriesResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceCreateMultiTimeseriesResult) IsSetSuccess 

func (p *IClientRPCServiceCreateMultiTimeseriesResult) IsSetSuccess() bool

func (*IClientRPCServiceCreateMultiTimeseriesResult) Read 

func (p *IClientRPCServiceCreateMultiTimeseriesResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateMultiTimeseriesResult) ReadField0 

func (p *IClientRPCServiceCreateMultiTimeseriesResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateMultiTimeseriesResult) String 

func (p *IClientRPCServiceCreateMultiTimeseriesResult) String() string

func (*IClientRPCServiceCreateMultiTimeseriesResult) Write 

func (p *IClientRPCServiceCreateMultiTimeseriesResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateSchemaTemplateArgs 

type IClientRPCServiceCreateSchemaTemplateArgs struct {
	Req *TSCreateSchemaTemplateReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceCreateSchemaTemplateArgs 

func NewIClientRPCServiceCreateSchemaTemplateArgs() *IClientRPCServiceCreateSchemaTemplateArgs

func (*IClientRPCServiceCreateSchemaTemplateArgs) GetReq 

func (p *IClientRPCServiceCreateSchemaTemplateArgs) GetReq() *TSCreateSchemaTemplateReq

func (*IClientRPCServiceCreateSchemaTemplateArgs) IsSetReq 

func (p *IClientRPCServiceCreateSchemaTemplateArgs) IsSetReq() bool

func (*IClientRPCServiceCreateSchemaTemplateArgs) Read 

func (p *IClientRPCServiceCreateSchemaTemplateArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateSchemaTemplateArgs) ReadField1 

func (p *IClientRPCServiceCreateSchemaTemplateArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateSchemaTemplateArgs) String 

func (p *IClientRPCServiceCreateSchemaTemplateArgs) String() string

func (*IClientRPCServiceCreateSchemaTemplateArgs) Write 

func (p *IClientRPCServiceCreateSchemaTemplateArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateSchemaTemplateResult 

type IClientRPCServiceCreateSchemaTemplateResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceCreateSchemaTemplateResult 

func NewIClientRPCServiceCreateSchemaTemplateResult() *IClientRPCServiceCreateSchemaTemplateResult

func (*IClientRPCServiceCreateSchemaTemplateResult) GetSuccess 

func (p *IClientRPCServiceCreateSchemaTemplateResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceCreateSchemaTemplateResult) IsSetSuccess 

func (p *IClientRPCServiceCreateSchemaTemplateResult) IsSetSuccess() bool

func (*IClientRPCServiceCreateSchemaTemplateResult) Read 

func (p *IClientRPCServiceCreateSchemaTemplateResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateSchemaTemplateResult) ReadField0 

func (p *IClientRPCServiceCreateSchemaTemplateResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateSchemaTemplateResult) String 

func (p *IClientRPCServiceCreateSchemaTemplateResult) String() string

func (*IClientRPCServiceCreateSchemaTemplateResult) Write 

func (p *IClientRPCServiceCreateSchemaTemplateResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateTimeseriesArgs 

type IClientRPCServiceCreateTimeseriesArgs struct {
	Req *TSCreateTimeseriesReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceCreateTimeseriesArgs 

func NewIClientRPCServiceCreateTimeseriesArgs() *IClientRPCServiceCreateTimeseriesArgs

func (*IClientRPCServiceCreateTimeseriesArgs) GetReq 

func (p *IClientRPCServiceCreateTimeseriesArgs) GetReq() *TSCreateTimeseriesReq

func (*IClientRPCServiceCreateTimeseriesArgs) IsSetReq 

func (p *IClientRPCServiceCreateTimeseriesArgs) IsSetReq() bool

func (*IClientRPCServiceCreateTimeseriesArgs) Read 

func (p *IClientRPCServiceCreateTimeseriesArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateTimeseriesArgs) ReadField1 

func (p *IClientRPCServiceCreateTimeseriesArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateTimeseriesArgs) String 

func (p *IClientRPCServiceCreateTimeseriesArgs) String() string

func (*IClientRPCServiceCreateTimeseriesArgs) Write 

func (p *IClientRPCServiceCreateTimeseriesArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateTimeseriesResult 

type IClientRPCServiceCreateTimeseriesResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceCreateTimeseriesResult 

func NewIClientRPCServiceCreateTimeseriesResult() *IClientRPCServiceCreateTimeseriesResult

func (*IClientRPCServiceCreateTimeseriesResult) GetSuccess 

func (p *IClientRPCServiceCreateTimeseriesResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceCreateTimeseriesResult) IsSetSuccess 

func (p *IClientRPCServiceCreateTimeseriesResult) IsSetSuccess() bool

func (*IClientRPCServiceCreateTimeseriesResult) Read 

func (p *IClientRPCServiceCreateTimeseriesResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateTimeseriesResult) ReadField0 

func (p *IClientRPCServiceCreateTimeseriesResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateTimeseriesResult) String 

func (p *IClientRPCServiceCreateTimeseriesResult) String() string

func (*IClientRPCServiceCreateTimeseriesResult) Write 

func (p *IClientRPCServiceCreateTimeseriesResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs 

type IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs struct {
	Req *TCreateTimeseriesUsingSchemaTemplateReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs 

func NewIClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs() *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) GetReq 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) GetReq() *TCreateTimeseriesUsingSchemaTemplateReq

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) IsSetReq 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) IsSetReq() bool

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) Read 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) ReadField1 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) String 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) String() string

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) Write 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult 

type IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult 

func NewIClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult() *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) GetSuccess 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) IsSetSuccess 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) IsSetSuccess() bool

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) Read 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) ReadField0 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) String 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) String() string

func (*IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) Write 

func (p *IClientRPCServiceCreateTimeseriesUsingSchemaTemplateResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceDeleteDataArgs 

type IClientRPCServiceDeleteDataArgs struct {
	Req *TSDeleteDataReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceDeleteDataArgs 

func NewIClientRPCServiceDeleteDataArgs() *IClientRPCServiceDeleteDataArgs

func (*IClientRPCServiceDeleteDataArgs) GetReq 

func (p *IClientRPCServiceDeleteDataArgs) GetReq() *TSDeleteDataReq

func (*IClientRPCServiceDeleteDataArgs) IsSetReq 

func (p *IClientRPCServiceDeleteDataArgs) IsSetReq() bool

func (*IClientRPCServiceDeleteDataArgs) Read 

func (p *IClientRPCServiceDeleteDataArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteDataArgs) ReadField1 

func (p *IClientRPCServiceDeleteDataArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteDataArgs) String 

func (p *IClientRPCServiceDeleteDataArgs) String() string

func (*IClientRPCServiceDeleteDataArgs) Write 

func (p *IClientRPCServiceDeleteDataArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceDeleteDataResult 

type IClientRPCServiceDeleteDataResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceDeleteDataResult 

func NewIClientRPCServiceDeleteDataResult() *IClientRPCServiceDeleteDataResult

func (*IClientRPCServiceDeleteDataResult) GetSuccess 

func (p *IClientRPCServiceDeleteDataResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceDeleteDataResult) IsSetSuccess 

func (p *IClientRPCServiceDeleteDataResult) IsSetSuccess() bool

func (*IClientRPCServiceDeleteDataResult) Read 

func (p *IClientRPCServiceDeleteDataResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteDataResult) ReadField0 

func (p *IClientRPCServiceDeleteDataResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteDataResult) String 

func (p *IClientRPCServiceDeleteDataResult) String() string

func (*IClientRPCServiceDeleteDataResult) Write 

func (p *IClientRPCServiceDeleteDataResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceDeleteStorageGroupsArgs 

type IClientRPCServiceDeleteStorageGroupsArgs struct {
	SessionId    int64    `thrift:"sessionId,1" db:"sessionId" json:"sessionId"`
	StorageGroup []string `thrift:"storageGroup,2" db:"storageGroup" json:"storageGroup"`
}

Attributes:

  • SessionId
  • StorageGroup

func NewIClientRPCServiceDeleteStorageGroupsArgs 

func NewIClientRPCServiceDeleteStorageGroupsArgs() *IClientRPCServiceDeleteStorageGroupsArgs

func (*IClientRPCServiceDeleteStorageGroupsArgs) GetSessionId 

func (p *IClientRPCServiceDeleteStorageGroupsArgs) GetSessionId() int64

func (*IClientRPCServiceDeleteStorageGroupsArgs) GetStorageGroup 

func (p *IClientRPCServiceDeleteStorageGroupsArgs) GetStorageGroup() []string

func (*IClientRPCServiceDeleteStorageGroupsArgs) Read 

func (p *IClientRPCServiceDeleteStorageGroupsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteStorageGroupsArgs) ReadField1 

func (p *IClientRPCServiceDeleteStorageGroupsArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteStorageGroupsArgs) ReadField2 

func (p *IClientRPCServiceDeleteStorageGroupsArgs) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteStorageGroupsArgs) String 

func (p *IClientRPCServiceDeleteStorageGroupsArgs) String() string

func (*IClientRPCServiceDeleteStorageGroupsArgs) Write 

func (p *IClientRPCServiceDeleteStorageGroupsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceDeleteStorageGroupsResult 

type IClientRPCServiceDeleteStorageGroupsResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceDeleteStorageGroupsResult 

func NewIClientRPCServiceDeleteStorageGroupsResult() *IClientRPCServiceDeleteStorageGroupsResult

func (*IClientRPCServiceDeleteStorageGroupsResult) GetSuccess 

func (p *IClientRPCServiceDeleteStorageGroupsResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceDeleteStorageGroupsResult) IsSetSuccess 

func (p *IClientRPCServiceDeleteStorageGroupsResult) IsSetSuccess() bool

func (*IClientRPCServiceDeleteStorageGroupsResult) Read 

func (p *IClientRPCServiceDeleteStorageGroupsResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteStorageGroupsResult) ReadField0 

func (p *IClientRPCServiceDeleteStorageGroupsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteStorageGroupsResult) String 

func (p *IClientRPCServiceDeleteStorageGroupsResult) String() string

func (*IClientRPCServiceDeleteStorageGroupsResult) Write 

func (p *IClientRPCServiceDeleteStorageGroupsResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceDeleteTimeseriesArgs 

type IClientRPCServiceDeleteTimeseriesArgs struct {
	SessionId int64    `thrift:"sessionId,1" db:"sessionId" json:"sessionId"`
	Path      []string `thrift:"path,2" db:"path" json:"path"`
}

Attributes:

  • SessionId
  • Path

func NewIClientRPCServiceDeleteTimeseriesArgs 

func NewIClientRPCServiceDeleteTimeseriesArgs() *IClientRPCServiceDeleteTimeseriesArgs

func (*IClientRPCServiceDeleteTimeseriesArgs) GetPath 

func (p *IClientRPCServiceDeleteTimeseriesArgs) GetPath() []string

func (*IClientRPCServiceDeleteTimeseriesArgs) GetSessionId 

func (p *IClientRPCServiceDeleteTimeseriesArgs) GetSessionId() int64

func (*IClientRPCServiceDeleteTimeseriesArgs) Read 

func (p *IClientRPCServiceDeleteTimeseriesArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteTimeseriesArgs) ReadField1 

func (p *IClientRPCServiceDeleteTimeseriesArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteTimeseriesArgs) ReadField2 

func (p *IClientRPCServiceDeleteTimeseriesArgs) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteTimeseriesArgs) String 

func (p *IClientRPCServiceDeleteTimeseriesArgs) String() string

func (*IClientRPCServiceDeleteTimeseriesArgs) Write 

func (p *IClientRPCServiceDeleteTimeseriesArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceDeleteTimeseriesResult 

type IClientRPCServiceDeleteTimeseriesResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceDeleteTimeseriesResult 

func NewIClientRPCServiceDeleteTimeseriesResult() *IClientRPCServiceDeleteTimeseriesResult

func (*IClientRPCServiceDeleteTimeseriesResult) GetSuccess 

func (p *IClientRPCServiceDeleteTimeseriesResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceDeleteTimeseriesResult) IsSetSuccess 

func (p *IClientRPCServiceDeleteTimeseriesResult) IsSetSuccess() bool

func (*IClientRPCServiceDeleteTimeseriesResult) Read 

func (p *IClientRPCServiceDeleteTimeseriesResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteTimeseriesResult) ReadField0 

func (p *IClientRPCServiceDeleteTimeseriesResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDeleteTimeseriesResult) String 

func (p *IClientRPCServiceDeleteTimeseriesResult) String() string

func (*IClientRPCServiceDeleteTimeseriesResult) Write 

func (p *IClientRPCServiceDeleteTimeseriesResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceDropSchemaTemplateArgs 

type IClientRPCServiceDropSchemaTemplateArgs struct {
	Req *TSDropSchemaTemplateReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceDropSchemaTemplateArgs 

func NewIClientRPCServiceDropSchemaTemplateArgs() *IClientRPCServiceDropSchemaTemplateArgs

func (*IClientRPCServiceDropSchemaTemplateArgs) GetReq 

func (p *IClientRPCServiceDropSchemaTemplateArgs) GetReq() *TSDropSchemaTemplateReq

func (*IClientRPCServiceDropSchemaTemplateArgs) IsSetReq 

func (p *IClientRPCServiceDropSchemaTemplateArgs) IsSetReq() bool

func (*IClientRPCServiceDropSchemaTemplateArgs) Read 

func (p *IClientRPCServiceDropSchemaTemplateArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDropSchemaTemplateArgs) ReadField1 

func (p *IClientRPCServiceDropSchemaTemplateArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDropSchemaTemplateArgs) String 

func (p *IClientRPCServiceDropSchemaTemplateArgs) String() string

func (*IClientRPCServiceDropSchemaTemplateArgs) Write 

func (p *IClientRPCServiceDropSchemaTemplateArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceDropSchemaTemplateResult 

type IClientRPCServiceDropSchemaTemplateResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceDropSchemaTemplateResult 

func NewIClientRPCServiceDropSchemaTemplateResult() *IClientRPCServiceDropSchemaTemplateResult

func (*IClientRPCServiceDropSchemaTemplateResult) GetSuccess 

func (p *IClientRPCServiceDropSchemaTemplateResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceDropSchemaTemplateResult) IsSetSuccess 

func (p *IClientRPCServiceDropSchemaTemplateResult) IsSetSuccess() bool

func (*IClientRPCServiceDropSchemaTemplateResult) Read 

func (p *IClientRPCServiceDropSchemaTemplateResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDropSchemaTemplateResult) ReadField0 

func (p *IClientRPCServiceDropSchemaTemplateResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceDropSchemaTemplateResult) String 

func (p *IClientRPCServiceDropSchemaTemplateResult) String() string

func (*IClientRPCServiceDropSchemaTemplateResult) Write 

func (p *IClientRPCServiceDropSchemaTemplateResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteAggregationQueryArgs 

type IClientRPCServiceExecuteAggregationQueryArgs struct {
	Req *TSAggregationQueryReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteAggregationQueryArgs 

func NewIClientRPCServiceExecuteAggregationQueryArgs() *IClientRPCServiceExecuteAggregationQueryArgs

func (*IClientRPCServiceExecuteAggregationQueryArgs) GetReq 

func (p *IClientRPCServiceExecuteAggregationQueryArgs) GetReq() *TSAggregationQueryReq

func (*IClientRPCServiceExecuteAggregationQueryArgs) IsSetReq 

func (p *IClientRPCServiceExecuteAggregationQueryArgs) IsSetReq() bool

func (*IClientRPCServiceExecuteAggregationQueryArgs) Read 

func (p *IClientRPCServiceExecuteAggregationQueryArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteAggregationQueryArgs) ReadField1 

func (p *IClientRPCServiceExecuteAggregationQueryArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteAggregationQueryArgs) String 

func (p *IClientRPCServiceExecuteAggregationQueryArgs) String() string

func (*IClientRPCServiceExecuteAggregationQueryArgs) Write 

func (p *IClientRPCServiceExecuteAggregationQueryArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteAggregationQueryResult 

type IClientRPCServiceExecuteAggregationQueryResult struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteAggregationQueryResult 

func NewIClientRPCServiceExecuteAggregationQueryResult() *IClientRPCServiceExecuteAggregationQueryResult

func (*IClientRPCServiceExecuteAggregationQueryResult) GetSuccess 

func (p *IClientRPCServiceExecuteAggregationQueryResult) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteAggregationQueryResult) IsSetSuccess 

func (p *IClientRPCServiceExecuteAggregationQueryResult) IsSetSuccess() bool

func (*IClientRPCServiceExecuteAggregationQueryResult) Read 

func (p *IClientRPCServiceExecuteAggregationQueryResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteAggregationQueryResult) ReadField0 

func (p *IClientRPCServiceExecuteAggregationQueryResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteAggregationQueryResult) String 

func (p *IClientRPCServiceExecuteAggregationQueryResult) String() string

func (*IClientRPCServiceExecuteAggregationQueryResult) Write 

func (p *IClientRPCServiceExecuteAggregationQueryResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteAggregationQueryV2Args 

type IClientRPCServiceExecuteAggregationQueryV2Args struct {
	Req *TSAggregationQueryReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteAggregationQueryV2Args 

func NewIClientRPCServiceExecuteAggregationQueryV2Args() *IClientRPCServiceExecuteAggregationQueryV2Args

func (*IClientRPCServiceExecuteAggregationQueryV2Args) GetReq 

func (p *IClientRPCServiceExecuteAggregationQueryV2Args) GetReq() *TSAggregationQueryReq

func (*IClientRPCServiceExecuteAggregationQueryV2Args) IsSetReq 

func (p *IClientRPCServiceExecuteAggregationQueryV2Args) IsSetReq() bool

func (*IClientRPCServiceExecuteAggregationQueryV2Args) Read 

func (p *IClientRPCServiceExecuteAggregationQueryV2Args) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteAggregationQueryV2Args) ReadField1 

func (p *IClientRPCServiceExecuteAggregationQueryV2Args) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteAggregationQueryV2Args) String 

func (p *IClientRPCServiceExecuteAggregationQueryV2Args) String() string

func (*IClientRPCServiceExecuteAggregationQueryV2Args) Write 

func (p *IClientRPCServiceExecuteAggregationQueryV2Args) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteAggregationQueryV2Result 

type IClientRPCServiceExecuteAggregationQueryV2Result struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteAggregationQueryV2Result 

func NewIClientRPCServiceExecuteAggregationQueryV2Result() *IClientRPCServiceExecuteAggregationQueryV2Result

func (*IClientRPCServiceExecuteAggregationQueryV2Result) GetSuccess 

func (p *IClientRPCServiceExecuteAggregationQueryV2Result) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteAggregationQueryV2Result) IsSetSuccess 

func (p *IClientRPCServiceExecuteAggregationQueryV2Result) IsSetSuccess() bool

func (*IClientRPCServiceExecuteAggregationQueryV2Result) Read 

func (p *IClientRPCServiceExecuteAggregationQueryV2Result) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteAggregationQueryV2Result) ReadField0 

func (p *IClientRPCServiceExecuteAggregationQueryV2Result) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteAggregationQueryV2Result) String 

func (p *IClientRPCServiceExecuteAggregationQueryV2Result) String() string

func (*IClientRPCServiceExecuteAggregationQueryV2Result) Write 

func (p *IClientRPCServiceExecuteAggregationQueryV2Result) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteBatchStatementArgs 

type IClientRPCServiceExecuteBatchStatementArgs struct {
	Req *TSExecuteBatchStatementReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteBatchStatementArgs 

func NewIClientRPCServiceExecuteBatchStatementArgs() *IClientRPCServiceExecuteBatchStatementArgs

func (*IClientRPCServiceExecuteBatchStatementArgs) GetReq 

func (p *IClientRPCServiceExecuteBatchStatementArgs) GetReq() *TSExecuteBatchStatementReq

func (*IClientRPCServiceExecuteBatchStatementArgs) IsSetReq 

func (p *IClientRPCServiceExecuteBatchStatementArgs) IsSetReq() bool

func (*IClientRPCServiceExecuteBatchStatementArgs) Read 

func (p *IClientRPCServiceExecuteBatchStatementArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteBatchStatementArgs) ReadField1 

func (p *IClientRPCServiceExecuteBatchStatementArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteBatchStatementArgs) String 

func (p *IClientRPCServiceExecuteBatchStatementArgs) String() string

func (*IClientRPCServiceExecuteBatchStatementArgs) Write 

func (p *IClientRPCServiceExecuteBatchStatementArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteBatchStatementResult 

type IClientRPCServiceExecuteBatchStatementResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteBatchStatementResult 

func NewIClientRPCServiceExecuteBatchStatementResult() *IClientRPCServiceExecuteBatchStatementResult

func (*IClientRPCServiceExecuteBatchStatementResult) GetSuccess 

func (p *IClientRPCServiceExecuteBatchStatementResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceExecuteBatchStatementResult) IsSetSuccess 

func (p *IClientRPCServiceExecuteBatchStatementResult) IsSetSuccess() bool

func (*IClientRPCServiceExecuteBatchStatementResult) Read 

func (p *IClientRPCServiceExecuteBatchStatementResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteBatchStatementResult) ReadField0 

func (p *IClientRPCServiceExecuteBatchStatementResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteBatchStatementResult) String 

func (p *IClientRPCServiceExecuteBatchStatementResult) String() string

func (*IClientRPCServiceExecuteBatchStatementResult) Write 

func (p *IClientRPCServiceExecuteBatchStatementResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args 

type IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args struct {
	Req *TSFastLastDataQueryForOneDeviceReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args 

func NewIClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args() *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) GetReq 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) GetReq() *TSFastLastDataQueryForOneDeviceReq

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) IsSetReq 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) IsSetReq() bool

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) Read 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) ReadField1 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) String 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) String() string

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) Write 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result 

type IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result 

func NewIClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result() *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) GetSuccess 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) IsSetSuccess 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) IsSetSuccess() bool

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) Read 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) ReadField0 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) String 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) String() string

func (*IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) Write 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs 

type IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs struct {
	Req *TSFastLastDataQueryForOnePrefixPathReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs 

func NewIClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs() *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) GetReq 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) GetReq() *TSFastLastDataQueryForOnePrefixPathReq

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) IsSetReq 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) IsSetReq() bool

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) Read 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) ReadField1 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) String 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) String() string

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) Write 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult 

type IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult 

func NewIClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult() *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) GetSuccess 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) IsSetSuccess 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) IsSetSuccess() bool

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) Read 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) ReadField0 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) String 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) String() string

func (*IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) Write 

func (p *IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs 

type IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs struct {
	Req *TSGroupByQueryIntervalReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteGroupByQueryIntervalQueryArgs 

func NewIClientRPCServiceExecuteGroupByQueryIntervalQueryArgs() *IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) GetReq 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) GetReq() *TSGroupByQueryIntervalReq

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) IsSetReq 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) IsSetReq() bool

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) Read 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) ReadField1 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) String 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) String() string

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) Write 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteGroupByQueryIntervalQueryResult 

type IClientRPCServiceExecuteGroupByQueryIntervalQueryResult struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteGroupByQueryIntervalQueryResult 

func NewIClientRPCServiceExecuteGroupByQueryIntervalQueryResult() *IClientRPCServiceExecuteGroupByQueryIntervalQueryResult

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) GetSuccess 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) IsSetSuccess 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) IsSetSuccess() bool

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) Read 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) ReadField0 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) String 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) String() string

func (*IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) Write 

func (p *IClientRPCServiceExecuteGroupByQueryIntervalQueryResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteLastDataQueryArgs 

type IClientRPCServiceExecuteLastDataQueryArgs struct {
	Req *TSLastDataQueryReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteLastDataQueryArgs 

func NewIClientRPCServiceExecuteLastDataQueryArgs() *IClientRPCServiceExecuteLastDataQueryArgs

func (*IClientRPCServiceExecuteLastDataQueryArgs) GetReq 

func (p *IClientRPCServiceExecuteLastDataQueryArgs) GetReq() *TSLastDataQueryReq

func (*IClientRPCServiceExecuteLastDataQueryArgs) IsSetReq 

func (p *IClientRPCServiceExecuteLastDataQueryArgs) IsSetReq() bool

func (*IClientRPCServiceExecuteLastDataQueryArgs) Read 

func (p *IClientRPCServiceExecuteLastDataQueryArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteLastDataQueryArgs) ReadField1 

func (p *IClientRPCServiceExecuteLastDataQueryArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteLastDataQueryArgs) String 

func (p *IClientRPCServiceExecuteLastDataQueryArgs) String() string

func (*IClientRPCServiceExecuteLastDataQueryArgs) Write 

func (p *IClientRPCServiceExecuteLastDataQueryArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteLastDataQueryResult 

type IClientRPCServiceExecuteLastDataQueryResult struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteLastDataQueryResult 

func NewIClientRPCServiceExecuteLastDataQueryResult() *IClientRPCServiceExecuteLastDataQueryResult

func (*IClientRPCServiceExecuteLastDataQueryResult) GetSuccess 

func (p *IClientRPCServiceExecuteLastDataQueryResult) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteLastDataQueryResult) IsSetSuccess 

func (p *IClientRPCServiceExecuteLastDataQueryResult) IsSetSuccess() bool

func (*IClientRPCServiceExecuteLastDataQueryResult) Read 

func (p *IClientRPCServiceExecuteLastDataQueryResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteLastDataQueryResult) ReadField0 

func (p *IClientRPCServiceExecuteLastDataQueryResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteLastDataQueryResult) String 

func (p *IClientRPCServiceExecuteLastDataQueryResult) String() string

func (*IClientRPCServiceExecuteLastDataQueryResult) Write 

func (p *IClientRPCServiceExecuteLastDataQueryResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteLastDataQueryV2Args 

type IClientRPCServiceExecuteLastDataQueryV2Args struct {
	Req *TSLastDataQueryReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteLastDataQueryV2Args 

func NewIClientRPCServiceExecuteLastDataQueryV2Args() *IClientRPCServiceExecuteLastDataQueryV2Args

func (*IClientRPCServiceExecuteLastDataQueryV2Args) GetReq 

func (p *IClientRPCServiceExecuteLastDataQueryV2Args) GetReq() *TSLastDataQueryReq

func (*IClientRPCServiceExecuteLastDataQueryV2Args) IsSetReq 

func (p *IClientRPCServiceExecuteLastDataQueryV2Args) IsSetReq() bool

func (*IClientRPCServiceExecuteLastDataQueryV2Args) Read 

func (p *IClientRPCServiceExecuteLastDataQueryV2Args) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteLastDataQueryV2Args) ReadField1 

func (p *IClientRPCServiceExecuteLastDataQueryV2Args) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteLastDataQueryV2Args) String 

func (p *IClientRPCServiceExecuteLastDataQueryV2Args) String() string

func (*IClientRPCServiceExecuteLastDataQueryV2Args) Write 

func (p *IClientRPCServiceExecuteLastDataQueryV2Args) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteLastDataQueryV2Result 

type IClientRPCServiceExecuteLastDataQueryV2Result struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteLastDataQueryV2Result 

func NewIClientRPCServiceExecuteLastDataQueryV2Result() *IClientRPCServiceExecuteLastDataQueryV2Result

func (*IClientRPCServiceExecuteLastDataQueryV2Result) GetSuccess 

func (p *IClientRPCServiceExecuteLastDataQueryV2Result) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteLastDataQueryV2Result) IsSetSuccess 

func (p *IClientRPCServiceExecuteLastDataQueryV2Result) IsSetSuccess() bool

func (*IClientRPCServiceExecuteLastDataQueryV2Result) Read 

func (p *IClientRPCServiceExecuteLastDataQueryV2Result) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteLastDataQueryV2Result) ReadField0 

func (p *IClientRPCServiceExecuteLastDataQueryV2Result) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteLastDataQueryV2Result) String 

func (p *IClientRPCServiceExecuteLastDataQueryV2Result) String() string

func (*IClientRPCServiceExecuteLastDataQueryV2Result) Write 

func (p *IClientRPCServiceExecuteLastDataQueryV2Result) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteQueryStatementArgs 

type IClientRPCServiceExecuteQueryStatementArgs struct {
	Req *TSExecuteStatementReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteQueryStatementArgs 

func NewIClientRPCServiceExecuteQueryStatementArgs() *IClientRPCServiceExecuteQueryStatementArgs

func (*IClientRPCServiceExecuteQueryStatementArgs) GetReq 

func (p *IClientRPCServiceExecuteQueryStatementArgs) GetReq() *TSExecuteStatementReq

func (*IClientRPCServiceExecuteQueryStatementArgs) IsSetReq 

func (p *IClientRPCServiceExecuteQueryStatementArgs) IsSetReq() bool

func (*IClientRPCServiceExecuteQueryStatementArgs) Read 

func (p *IClientRPCServiceExecuteQueryStatementArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteQueryStatementArgs) ReadField1 

func (p *IClientRPCServiceExecuteQueryStatementArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteQueryStatementArgs) String 

func (p *IClientRPCServiceExecuteQueryStatementArgs) String() string

func (*IClientRPCServiceExecuteQueryStatementArgs) Write 

func (p *IClientRPCServiceExecuteQueryStatementArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteQueryStatementResult 

type IClientRPCServiceExecuteQueryStatementResult struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteQueryStatementResult 

func NewIClientRPCServiceExecuteQueryStatementResult() *IClientRPCServiceExecuteQueryStatementResult

func (*IClientRPCServiceExecuteQueryStatementResult) GetSuccess 

func (p *IClientRPCServiceExecuteQueryStatementResult) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteQueryStatementResult) IsSetSuccess 

func (p *IClientRPCServiceExecuteQueryStatementResult) IsSetSuccess() bool

func (*IClientRPCServiceExecuteQueryStatementResult) Read 

func (p *IClientRPCServiceExecuteQueryStatementResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteQueryStatementResult) ReadField0 

func (p *IClientRPCServiceExecuteQueryStatementResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteQueryStatementResult) String 

func (p *IClientRPCServiceExecuteQueryStatementResult) String() string

func (*IClientRPCServiceExecuteQueryStatementResult) Write 

func (p *IClientRPCServiceExecuteQueryStatementResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteQueryStatementV2Args 

type IClientRPCServiceExecuteQueryStatementV2Args struct {
	Req *TSExecuteStatementReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteQueryStatementV2Args 

func NewIClientRPCServiceExecuteQueryStatementV2Args() *IClientRPCServiceExecuteQueryStatementV2Args

func (*IClientRPCServiceExecuteQueryStatementV2Args) GetReq 

func (p *IClientRPCServiceExecuteQueryStatementV2Args) GetReq() *TSExecuteStatementReq

func (*IClientRPCServiceExecuteQueryStatementV2Args) IsSetReq 

func (p *IClientRPCServiceExecuteQueryStatementV2Args) IsSetReq() bool

func (*IClientRPCServiceExecuteQueryStatementV2Args) Read 

func (p *IClientRPCServiceExecuteQueryStatementV2Args) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteQueryStatementV2Args) ReadField1 

func (p *IClientRPCServiceExecuteQueryStatementV2Args) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteQueryStatementV2Args) String 

func (p *IClientRPCServiceExecuteQueryStatementV2Args) String() string

func (*IClientRPCServiceExecuteQueryStatementV2Args) Write 

func (p *IClientRPCServiceExecuteQueryStatementV2Args) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteQueryStatementV2Result 

type IClientRPCServiceExecuteQueryStatementV2Result struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteQueryStatementV2Result 

func NewIClientRPCServiceExecuteQueryStatementV2Result() *IClientRPCServiceExecuteQueryStatementV2Result

func (*IClientRPCServiceExecuteQueryStatementV2Result) GetSuccess 

func (p *IClientRPCServiceExecuteQueryStatementV2Result) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteQueryStatementV2Result) IsSetSuccess 

func (p *IClientRPCServiceExecuteQueryStatementV2Result) IsSetSuccess() bool

func (*IClientRPCServiceExecuteQueryStatementV2Result) Read 

func (p *IClientRPCServiceExecuteQueryStatementV2Result) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteQueryStatementV2Result) ReadField0 

func (p *IClientRPCServiceExecuteQueryStatementV2Result) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteQueryStatementV2Result) String 

func (p *IClientRPCServiceExecuteQueryStatementV2Result) String() string

func (*IClientRPCServiceExecuteQueryStatementV2Result) Write 

func (p *IClientRPCServiceExecuteQueryStatementV2Result) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteRawDataQueryArgs 

type IClientRPCServiceExecuteRawDataQueryArgs struct {
	Req *TSRawDataQueryReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteRawDataQueryArgs 

func NewIClientRPCServiceExecuteRawDataQueryArgs() *IClientRPCServiceExecuteRawDataQueryArgs

func (*IClientRPCServiceExecuteRawDataQueryArgs) GetReq 

func (p *IClientRPCServiceExecuteRawDataQueryArgs) GetReq() *TSRawDataQueryReq

func (*IClientRPCServiceExecuteRawDataQueryArgs) IsSetReq 

func (p *IClientRPCServiceExecuteRawDataQueryArgs) IsSetReq() bool

func (*IClientRPCServiceExecuteRawDataQueryArgs) Read 

func (p *IClientRPCServiceExecuteRawDataQueryArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteRawDataQueryArgs) ReadField1 

func (p *IClientRPCServiceExecuteRawDataQueryArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteRawDataQueryArgs) String 

func (p *IClientRPCServiceExecuteRawDataQueryArgs) String() string

func (*IClientRPCServiceExecuteRawDataQueryArgs) Write 

func (p *IClientRPCServiceExecuteRawDataQueryArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteRawDataQueryResult 

type IClientRPCServiceExecuteRawDataQueryResult struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteRawDataQueryResult 

func NewIClientRPCServiceExecuteRawDataQueryResult() *IClientRPCServiceExecuteRawDataQueryResult

func (*IClientRPCServiceExecuteRawDataQueryResult) GetSuccess 

func (p *IClientRPCServiceExecuteRawDataQueryResult) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteRawDataQueryResult) IsSetSuccess 

func (p *IClientRPCServiceExecuteRawDataQueryResult) IsSetSuccess() bool

func (*IClientRPCServiceExecuteRawDataQueryResult) Read 

func (p *IClientRPCServiceExecuteRawDataQueryResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteRawDataQueryResult) ReadField0 

func (p *IClientRPCServiceExecuteRawDataQueryResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteRawDataQueryResult) String 

func (p *IClientRPCServiceExecuteRawDataQueryResult) String() string

func (*IClientRPCServiceExecuteRawDataQueryResult) Write 

func (p *IClientRPCServiceExecuteRawDataQueryResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteRawDataQueryV2Args 

type IClientRPCServiceExecuteRawDataQueryV2Args struct {
	Req *TSRawDataQueryReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteRawDataQueryV2Args 

func NewIClientRPCServiceExecuteRawDataQueryV2Args() *IClientRPCServiceExecuteRawDataQueryV2Args

func (*IClientRPCServiceExecuteRawDataQueryV2Args) GetReq 

func (p *IClientRPCServiceExecuteRawDataQueryV2Args) GetReq() *TSRawDataQueryReq

func (*IClientRPCServiceExecuteRawDataQueryV2Args) IsSetReq 

func (p *IClientRPCServiceExecuteRawDataQueryV2Args) IsSetReq() bool

func (*IClientRPCServiceExecuteRawDataQueryV2Args) Read 

func (p *IClientRPCServiceExecuteRawDataQueryV2Args) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteRawDataQueryV2Args) ReadField1 

func (p *IClientRPCServiceExecuteRawDataQueryV2Args) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteRawDataQueryV2Args) String 

func (p *IClientRPCServiceExecuteRawDataQueryV2Args) String() string

func (*IClientRPCServiceExecuteRawDataQueryV2Args) Write 

func (p *IClientRPCServiceExecuteRawDataQueryV2Args) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteRawDataQueryV2Result 

type IClientRPCServiceExecuteRawDataQueryV2Result struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteRawDataQueryV2Result 

func NewIClientRPCServiceExecuteRawDataQueryV2Result() *IClientRPCServiceExecuteRawDataQueryV2Result

func (*IClientRPCServiceExecuteRawDataQueryV2Result) GetSuccess 

func (p *IClientRPCServiceExecuteRawDataQueryV2Result) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteRawDataQueryV2Result) IsSetSuccess 

func (p *IClientRPCServiceExecuteRawDataQueryV2Result) IsSetSuccess() bool

func (*IClientRPCServiceExecuteRawDataQueryV2Result) Read 

func (p *IClientRPCServiceExecuteRawDataQueryV2Result) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteRawDataQueryV2Result) ReadField0 

func (p *IClientRPCServiceExecuteRawDataQueryV2Result) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteRawDataQueryV2Result) String 

func (p *IClientRPCServiceExecuteRawDataQueryV2Result) String() string

func (*IClientRPCServiceExecuteRawDataQueryV2Result) Write 

func (p *IClientRPCServiceExecuteRawDataQueryV2Result) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteStatementArgs 

type IClientRPCServiceExecuteStatementArgs struct {
	Req *TSExecuteStatementReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteStatementArgs 

func NewIClientRPCServiceExecuteStatementArgs() *IClientRPCServiceExecuteStatementArgs

func (*IClientRPCServiceExecuteStatementArgs) GetReq 

func (p *IClientRPCServiceExecuteStatementArgs) GetReq() *TSExecuteStatementReq

func (*IClientRPCServiceExecuteStatementArgs) IsSetReq 

func (p *IClientRPCServiceExecuteStatementArgs) IsSetReq() bool

func (*IClientRPCServiceExecuteStatementArgs) Read 

func (p *IClientRPCServiceExecuteStatementArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteStatementArgs) ReadField1 

func (p *IClientRPCServiceExecuteStatementArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteStatementArgs) String 

func (p *IClientRPCServiceExecuteStatementArgs) String() string

func (*IClientRPCServiceExecuteStatementArgs) Write 

func (p *IClientRPCServiceExecuteStatementArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteStatementResult 

type IClientRPCServiceExecuteStatementResult struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteStatementResult 

func NewIClientRPCServiceExecuteStatementResult() *IClientRPCServiceExecuteStatementResult

func (*IClientRPCServiceExecuteStatementResult) GetSuccess 

func (p *IClientRPCServiceExecuteStatementResult) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteStatementResult) IsSetSuccess 

func (p *IClientRPCServiceExecuteStatementResult) IsSetSuccess() bool

func (*IClientRPCServiceExecuteStatementResult) Read 

func (p *IClientRPCServiceExecuteStatementResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteStatementResult) ReadField0 

func (p *IClientRPCServiceExecuteStatementResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteStatementResult) String 

func (p *IClientRPCServiceExecuteStatementResult) String() string

func (*IClientRPCServiceExecuteStatementResult) Write 

func (p *IClientRPCServiceExecuteStatementResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteStatementV2Args 

type IClientRPCServiceExecuteStatementV2Args struct {
	Req *TSExecuteStatementReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteStatementV2Args 

func NewIClientRPCServiceExecuteStatementV2Args() *IClientRPCServiceExecuteStatementV2Args

func (*IClientRPCServiceExecuteStatementV2Args) GetReq 

func (p *IClientRPCServiceExecuteStatementV2Args) GetReq() *TSExecuteStatementReq

func (*IClientRPCServiceExecuteStatementV2Args) IsSetReq 

func (p *IClientRPCServiceExecuteStatementV2Args) IsSetReq() bool

func (*IClientRPCServiceExecuteStatementV2Args) Read 

func (p *IClientRPCServiceExecuteStatementV2Args) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteStatementV2Args) ReadField1 

func (p *IClientRPCServiceExecuteStatementV2Args) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteStatementV2Args) String 

func (p *IClientRPCServiceExecuteStatementV2Args) String() string

func (*IClientRPCServiceExecuteStatementV2Args) Write 

func (p *IClientRPCServiceExecuteStatementV2Args) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteStatementV2Result 

type IClientRPCServiceExecuteStatementV2Result struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteStatementV2Result 

func NewIClientRPCServiceExecuteStatementV2Result() *IClientRPCServiceExecuteStatementV2Result

func (*IClientRPCServiceExecuteStatementV2Result) GetSuccess 

func (p *IClientRPCServiceExecuteStatementV2Result) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteStatementV2Result) IsSetSuccess 

func (p *IClientRPCServiceExecuteStatementV2Result) IsSetSuccess() bool

func (*IClientRPCServiceExecuteStatementV2Result) Read 

func (p *IClientRPCServiceExecuteStatementV2Result) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteStatementV2Result) ReadField0 

func (p *IClientRPCServiceExecuteStatementV2Result) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteStatementV2Result) String 

func (p *IClientRPCServiceExecuteStatementV2Result) String() string

func (*IClientRPCServiceExecuteStatementV2Result) Write 

func (p *IClientRPCServiceExecuteStatementV2Result) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteUpdateStatementArgs 

type IClientRPCServiceExecuteUpdateStatementArgs struct {
	Req *TSExecuteStatementReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteUpdateStatementArgs 

func NewIClientRPCServiceExecuteUpdateStatementArgs() *IClientRPCServiceExecuteUpdateStatementArgs

func (*IClientRPCServiceExecuteUpdateStatementArgs) GetReq 

func (p *IClientRPCServiceExecuteUpdateStatementArgs) GetReq() *TSExecuteStatementReq

func (*IClientRPCServiceExecuteUpdateStatementArgs) IsSetReq 

func (p *IClientRPCServiceExecuteUpdateStatementArgs) IsSetReq() bool

func (*IClientRPCServiceExecuteUpdateStatementArgs) Read 

func (p *IClientRPCServiceExecuteUpdateStatementArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteUpdateStatementArgs) ReadField1 

func (p *IClientRPCServiceExecuteUpdateStatementArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteUpdateStatementArgs) String 

func (p *IClientRPCServiceExecuteUpdateStatementArgs) String() string

func (*IClientRPCServiceExecuteUpdateStatementArgs) Write 

func (p *IClientRPCServiceExecuteUpdateStatementArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteUpdateStatementResult 

type IClientRPCServiceExecuteUpdateStatementResult struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteUpdateStatementResult 

func NewIClientRPCServiceExecuteUpdateStatementResult() *IClientRPCServiceExecuteUpdateStatementResult

func (*IClientRPCServiceExecuteUpdateStatementResult) GetSuccess 

func (p *IClientRPCServiceExecuteUpdateStatementResult) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteUpdateStatementResult) IsSetSuccess 

func (p *IClientRPCServiceExecuteUpdateStatementResult) IsSetSuccess() bool

func (*IClientRPCServiceExecuteUpdateStatementResult) Read 

func (p *IClientRPCServiceExecuteUpdateStatementResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteUpdateStatementResult) ReadField0 

func (p *IClientRPCServiceExecuteUpdateStatementResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteUpdateStatementResult) String 

func (p *IClientRPCServiceExecuteUpdateStatementResult) String() string

func (*IClientRPCServiceExecuteUpdateStatementResult) Write 

func (p *IClientRPCServiceExecuteUpdateStatementResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteUpdateStatementV2Args 

type IClientRPCServiceExecuteUpdateStatementV2Args struct {
	Req *TSExecuteStatementReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceExecuteUpdateStatementV2Args 

func NewIClientRPCServiceExecuteUpdateStatementV2Args() *IClientRPCServiceExecuteUpdateStatementV2Args

func (*IClientRPCServiceExecuteUpdateStatementV2Args) GetReq 

func (p *IClientRPCServiceExecuteUpdateStatementV2Args) GetReq() *TSExecuteStatementReq

func (*IClientRPCServiceExecuteUpdateStatementV2Args) IsSetReq 

func (p *IClientRPCServiceExecuteUpdateStatementV2Args) IsSetReq() bool

func (*IClientRPCServiceExecuteUpdateStatementV2Args) Read 

func (p *IClientRPCServiceExecuteUpdateStatementV2Args) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteUpdateStatementV2Args) ReadField1 

func (p *IClientRPCServiceExecuteUpdateStatementV2Args) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteUpdateStatementV2Args) String 

func (p *IClientRPCServiceExecuteUpdateStatementV2Args) String() string

func (*IClientRPCServiceExecuteUpdateStatementV2Args) Write 

func (p *IClientRPCServiceExecuteUpdateStatementV2Args) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceExecuteUpdateStatementV2Result 

type IClientRPCServiceExecuteUpdateStatementV2Result struct {
	Success *TSExecuteStatementResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceExecuteUpdateStatementV2Result 

func NewIClientRPCServiceExecuteUpdateStatementV2Result() *IClientRPCServiceExecuteUpdateStatementV2Result

func (*IClientRPCServiceExecuteUpdateStatementV2Result) GetSuccess 

func (p *IClientRPCServiceExecuteUpdateStatementV2Result) GetSuccess() *TSExecuteStatementResp

func (*IClientRPCServiceExecuteUpdateStatementV2Result) IsSetSuccess 

func (p *IClientRPCServiceExecuteUpdateStatementV2Result) IsSetSuccess() bool

func (*IClientRPCServiceExecuteUpdateStatementV2Result) Read 

func (p *IClientRPCServiceExecuteUpdateStatementV2Result) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteUpdateStatementV2Result) ReadField0 

func (p *IClientRPCServiceExecuteUpdateStatementV2Result) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceExecuteUpdateStatementV2Result) String 

func (p *IClientRPCServiceExecuteUpdateStatementV2Result) String() string

func (*IClientRPCServiceExecuteUpdateStatementV2Result) Write 

func (p *IClientRPCServiceExecuteUpdateStatementV2Result) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceFetchAllConnectionsInfoArgs 

type IClientRPCServiceFetchAllConnectionsInfoArgs struct {
}

func NewIClientRPCServiceFetchAllConnectionsInfoArgs 

func NewIClientRPCServiceFetchAllConnectionsInfoArgs() *IClientRPCServiceFetchAllConnectionsInfoArgs

func (*IClientRPCServiceFetchAllConnectionsInfoArgs) Read 

func (p *IClientRPCServiceFetchAllConnectionsInfoArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchAllConnectionsInfoArgs) String 

func (p *IClientRPCServiceFetchAllConnectionsInfoArgs) String() string

func (*IClientRPCServiceFetchAllConnectionsInfoArgs) Write 

func (p *IClientRPCServiceFetchAllConnectionsInfoArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceFetchAllConnectionsInfoResult 

type IClientRPCServiceFetchAllConnectionsInfoResult struct {
	Success *TSConnectionInfoResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceFetchAllConnectionsInfoResult 

func NewIClientRPCServiceFetchAllConnectionsInfoResult() *IClientRPCServiceFetchAllConnectionsInfoResult

func (*IClientRPCServiceFetchAllConnectionsInfoResult) GetSuccess 

func (p *IClientRPCServiceFetchAllConnectionsInfoResult) GetSuccess() *TSConnectionInfoResp

func (*IClientRPCServiceFetchAllConnectionsInfoResult) IsSetSuccess 

func (p *IClientRPCServiceFetchAllConnectionsInfoResult) IsSetSuccess() bool

func (*IClientRPCServiceFetchAllConnectionsInfoResult) Read 

func (p *IClientRPCServiceFetchAllConnectionsInfoResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchAllConnectionsInfoResult) ReadField0 

func (p *IClientRPCServiceFetchAllConnectionsInfoResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchAllConnectionsInfoResult) String 

func (p *IClientRPCServiceFetchAllConnectionsInfoResult) String() string

func (*IClientRPCServiceFetchAllConnectionsInfoResult) Write 

func (p *IClientRPCServiceFetchAllConnectionsInfoResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceFetchMetadataArgs 

type IClientRPCServiceFetchMetadataArgs struct {
	Req *TSFetchMetadataReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceFetchMetadataArgs 

func NewIClientRPCServiceFetchMetadataArgs() *IClientRPCServiceFetchMetadataArgs

func (*IClientRPCServiceFetchMetadataArgs) GetReq 

func (p *IClientRPCServiceFetchMetadataArgs) GetReq() *TSFetchMetadataReq

func (*IClientRPCServiceFetchMetadataArgs) IsSetReq 

func (p *IClientRPCServiceFetchMetadataArgs) IsSetReq() bool

func (*IClientRPCServiceFetchMetadataArgs) Read 

func (p *IClientRPCServiceFetchMetadataArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchMetadataArgs) ReadField1 

func (p *IClientRPCServiceFetchMetadataArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchMetadataArgs) String 

func (p *IClientRPCServiceFetchMetadataArgs) String() string

func (*IClientRPCServiceFetchMetadataArgs) Write 

func (p *IClientRPCServiceFetchMetadataArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceFetchMetadataResult 

type IClientRPCServiceFetchMetadataResult struct {
	Success *TSFetchMetadataResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceFetchMetadataResult 

func NewIClientRPCServiceFetchMetadataResult() *IClientRPCServiceFetchMetadataResult

func (*IClientRPCServiceFetchMetadataResult) GetSuccess 

func (p *IClientRPCServiceFetchMetadataResult) GetSuccess() *TSFetchMetadataResp

func (*IClientRPCServiceFetchMetadataResult) IsSetSuccess 

func (p *IClientRPCServiceFetchMetadataResult) IsSetSuccess() bool

func (*IClientRPCServiceFetchMetadataResult) Read 

func (p *IClientRPCServiceFetchMetadataResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchMetadataResult) ReadField0 

func (p *IClientRPCServiceFetchMetadataResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchMetadataResult) String 

func (p *IClientRPCServiceFetchMetadataResult) String() string

func (*IClientRPCServiceFetchMetadataResult) Write 

func (p *IClientRPCServiceFetchMetadataResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceFetchResultsArgs 

type IClientRPCServiceFetchResultsArgs struct {
	Req *TSFetchResultsReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceFetchResultsArgs 

func NewIClientRPCServiceFetchResultsArgs() *IClientRPCServiceFetchResultsArgs

func (*IClientRPCServiceFetchResultsArgs) GetReq 

func (p *IClientRPCServiceFetchResultsArgs) GetReq() *TSFetchResultsReq

func (*IClientRPCServiceFetchResultsArgs) IsSetReq 

func (p *IClientRPCServiceFetchResultsArgs) IsSetReq() bool

func (*IClientRPCServiceFetchResultsArgs) Read 

func (p *IClientRPCServiceFetchResultsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchResultsArgs) ReadField1 

func (p *IClientRPCServiceFetchResultsArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchResultsArgs) String 

func (p *IClientRPCServiceFetchResultsArgs) String() string

func (*IClientRPCServiceFetchResultsArgs) Write 

func (p *IClientRPCServiceFetchResultsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceFetchResultsResult 

type IClientRPCServiceFetchResultsResult struct {
	Success *TSFetchResultsResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceFetchResultsResult 

func NewIClientRPCServiceFetchResultsResult() *IClientRPCServiceFetchResultsResult

func (*IClientRPCServiceFetchResultsResult) GetSuccess 

func (p *IClientRPCServiceFetchResultsResult) GetSuccess() *TSFetchResultsResp

func (*IClientRPCServiceFetchResultsResult) IsSetSuccess 

func (p *IClientRPCServiceFetchResultsResult) IsSetSuccess() bool

func (*IClientRPCServiceFetchResultsResult) Read 

func (p *IClientRPCServiceFetchResultsResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchResultsResult) ReadField0 

func (p *IClientRPCServiceFetchResultsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchResultsResult) String 

func (p *IClientRPCServiceFetchResultsResult) String() string

func (*IClientRPCServiceFetchResultsResult) Write 

func (p *IClientRPCServiceFetchResultsResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceFetchResultsV2Args 

type IClientRPCServiceFetchResultsV2Args struct {
	Req *TSFetchResultsReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceFetchResultsV2Args 

func NewIClientRPCServiceFetchResultsV2Args() *IClientRPCServiceFetchResultsV2Args

func (*IClientRPCServiceFetchResultsV2Args) GetReq 

func (p *IClientRPCServiceFetchResultsV2Args) GetReq() *TSFetchResultsReq

func (*IClientRPCServiceFetchResultsV2Args) IsSetReq 

func (p *IClientRPCServiceFetchResultsV2Args) IsSetReq() bool

func (*IClientRPCServiceFetchResultsV2Args) Read 

func (p *IClientRPCServiceFetchResultsV2Args) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchResultsV2Args) ReadField1 

func (p *IClientRPCServiceFetchResultsV2Args) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchResultsV2Args) String 

func (p *IClientRPCServiceFetchResultsV2Args) String() string

func (*IClientRPCServiceFetchResultsV2Args) Write 

func (p *IClientRPCServiceFetchResultsV2Args) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceFetchResultsV2Result 

type IClientRPCServiceFetchResultsV2Result struct {
	Success *TSFetchResultsResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceFetchResultsV2Result 

func NewIClientRPCServiceFetchResultsV2Result() *IClientRPCServiceFetchResultsV2Result

func (*IClientRPCServiceFetchResultsV2Result) GetSuccess 

func (p *IClientRPCServiceFetchResultsV2Result) GetSuccess() *TSFetchResultsResp

func (*IClientRPCServiceFetchResultsV2Result) IsSetSuccess 

func (p *IClientRPCServiceFetchResultsV2Result) IsSetSuccess() bool

func (*IClientRPCServiceFetchResultsV2Result) Read 

func (p *IClientRPCServiceFetchResultsV2Result) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchResultsV2Result) ReadField0 

func (p *IClientRPCServiceFetchResultsV2Result) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceFetchResultsV2Result) String 

func (p *IClientRPCServiceFetchResultsV2Result) String() string

func (*IClientRPCServiceFetchResultsV2Result) Write 

func (p *IClientRPCServiceFetchResultsV2Result) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceGetBackupConfigurationArgs 

type IClientRPCServiceGetBackupConfigurationArgs struct {
}

func NewIClientRPCServiceGetBackupConfigurationArgs 

func NewIClientRPCServiceGetBackupConfigurationArgs() *IClientRPCServiceGetBackupConfigurationArgs

func (*IClientRPCServiceGetBackupConfigurationArgs) Read 

func (p *IClientRPCServiceGetBackupConfigurationArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetBackupConfigurationArgs) String 

func (p *IClientRPCServiceGetBackupConfigurationArgs) String() string

func (*IClientRPCServiceGetBackupConfigurationArgs) Write 

func (p *IClientRPCServiceGetBackupConfigurationArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceGetBackupConfigurationResult 

type IClientRPCServiceGetBackupConfigurationResult struct {
	Success *TSBackupConfigurationResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceGetBackupConfigurationResult 

func NewIClientRPCServiceGetBackupConfigurationResult() *IClientRPCServiceGetBackupConfigurationResult

func (*IClientRPCServiceGetBackupConfigurationResult) GetSuccess 

func (p *IClientRPCServiceGetBackupConfigurationResult) GetSuccess() *TSBackupConfigurationResp

func (*IClientRPCServiceGetBackupConfigurationResult) IsSetSuccess 

func (p *IClientRPCServiceGetBackupConfigurationResult) IsSetSuccess() bool

func (*IClientRPCServiceGetBackupConfigurationResult) Read 

func (p *IClientRPCServiceGetBackupConfigurationResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetBackupConfigurationResult) ReadField0 

func (p *IClientRPCServiceGetBackupConfigurationResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetBackupConfigurationResult) String 

func (p *IClientRPCServiceGetBackupConfigurationResult) String() string

func (*IClientRPCServiceGetBackupConfigurationResult) Write 

func (p *IClientRPCServiceGetBackupConfigurationResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceGetPropertiesArgs 

type IClientRPCServiceGetPropertiesArgs struct {
}

func NewIClientRPCServiceGetPropertiesArgs 

func NewIClientRPCServiceGetPropertiesArgs() *IClientRPCServiceGetPropertiesArgs

func (*IClientRPCServiceGetPropertiesArgs) Read 

func (p *IClientRPCServiceGetPropertiesArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetPropertiesArgs) String 

func (p *IClientRPCServiceGetPropertiesArgs) String() string

func (*IClientRPCServiceGetPropertiesArgs) Write 

func (p *IClientRPCServiceGetPropertiesArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceGetPropertiesResult 

type IClientRPCServiceGetPropertiesResult struct {
	Success *ServerProperties `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceGetPropertiesResult 

func NewIClientRPCServiceGetPropertiesResult() *IClientRPCServiceGetPropertiesResult

func (*IClientRPCServiceGetPropertiesResult) GetSuccess 

func (p *IClientRPCServiceGetPropertiesResult) GetSuccess() *ServerProperties

func (*IClientRPCServiceGetPropertiesResult) IsSetSuccess 

func (p *IClientRPCServiceGetPropertiesResult) IsSetSuccess() bool

func (*IClientRPCServiceGetPropertiesResult) Read 

func (p *IClientRPCServiceGetPropertiesResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetPropertiesResult) ReadField0 

func (p *IClientRPCServiceGetPropertiesResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetPropertiesResult) String 

func (p *IClientRPCServiceGetPropertiesResult) String() string

func (*IClientRPCServiceGetPropertiesResult) Write 

func (p *IClientRPCServiceGetPropertiesResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceGetTimeZoneArgs 

type IClientRPCServiceGetTimeZoneArgs struct {
	SessionId int64 `thrift:"sessionId,1" db:"sessionId" json:"sessionId"`
}

Attributes:

  • SessionId

func NewIClientRPCServiceGetTimeZoneArgs 

func NewIClientRPCServiceGetTimeZoneArgs() *IClientRPCServiceGetTimeZoneArgs

func (*IClientRPCServiceGetTimeZoneArgs) GetSessionId 

func (p *IClientRPCServiceGetTimeZoneArgs) GetSessionId() int64

func (*IClientRPCServiceGetTimeZoneArgs) Read 

func (p *IClientRPCServiceGetTimeZoneArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetTimeZoneArgs) ReadField1 

func (p *IClientRPCServiceGetTimeZoneArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetTimeZoneArgs) String 

func (p *IClientRPCServiceGetTimeZoneArgs) String() string

func (*IClientRPCServiceGetTimeZoneArgs) Write 

func (p *IClientRPCServiceGetTimeZoneArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceGetTimeZoneResult 

type IClientRPCServiceGetTimeZoneResult struct {
	Success *TSGetTimeZoneResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceGetTimeZoneResult 

func NewIClientRPCServiceGetTimeZoneResult() *IClientRPCServiceGetTimeZoneResult

func (*IClientRPCServiceGetTimeZoneResult) GetSuccess 

func (p *IClientRPCServiceGetTimeZoneResult) GetSuccess() *TSGetTimeZoneResp

func (*IClientRPCServiceGetTimeZoneResult) IsSetSuccess 

func (p *IClientRPCServiceGetTimeZoneResult) IsSetSuccess() bool

func (*IClientRPCServiceGetTimeZoneResult) Read 

func (p *IClientRPCServiceGetTimeZoneResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetTimeZoneResult) ReadField0 

func (p *IClientRPCServiceGetTimeZoneResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceGetTimeZoneResult) String 

func (p *IClientRPCServiceGetTimeZoneResult) String() string

func (*IClientRPCServiceGetTimeZoneResult) Write 

func (p *IClientRPCServiceGetTimeZoneResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceHandshakeArgs 

type IClientRPCServiceHandshakeArgs struct {
	Info *TSyncIdentityInfo
}

Attributes:

  • Info

func NewIClientRPCServiceHandshakeArgs 

func NewIClientRPCServiceHandshakeArgs() *IClientRPCServiceHandshakeArgs

func (*IClientRPCServiceHandshakeArgs) GetInfo 

func (p *IClientRPCServiceHandshakeArgs) GetInfo() *TSyncIdentityInfo

func (*IClientRPCServiceHandshakeArgs) IsSetInfo 

func (p *IClientRPCServiceHandshakeArgs) IsSetInfo() bool

func (*IClientRPCServiceHandshakeArgs) Read 

func (p *IClientRPCServiceHandshakeArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceHandshakeArgs) ReadField_1 

func (p *IClientRPCServiceHandshakeArgs) ReadField_1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceHandshakeArgs) String 

func (p *IClientRPCServiceHandshakeArgs) String() string

func (*IClientRPCServiceHandshakeArgs) Write 

func (p *IClientRPCServiceHandshakeArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceHandshakeResult 

type IClientRPCServiceHandshakeResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceHandshakeResult 

func NewIClientRPCServiceHandshakeResult() *IClientRPCServiceHandshakeResult

func (*IClientRPCServiceHandshakeResult) GetSuccess 

func (p *IClientRPCServiceHandshakeResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceHandshakeResult) IsSetSuccess 

func (p *IClientRPCServiceHandshakeResult) IsSetSuccess() bool

func (*IClientRPCServiceHandshakeResult) Read 

func (p *IClientRPCServiceHandshakeResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceHandshakeResult) ReadField0 

func (p *IClientRPCServiceHandshakeResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceHandshakeResult) String 

func (p *IClientRPCServiceHandshakeResult) String() string

func (*IClientRPCServiceHandshakeResult) Write 

func (p *IClientRPCServiceHandshakeResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertRecordArgs 

type IClientRPCServiceInsertRecordArgs struct {
	Req *TSInsertRecordReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceInsertRecordArgs 

func NewIClientRPCServiceInsertRecordArgs() *IClientRPCServiceInsertRecordArgs

func (*IClientRPCServiceInsertRecordArgs) GetReq 

func (p *IClientRPCServiceInsertRecordArgs) GetReq() *TSInsertRecordReq

func (*IClientRPCServiceInsertRecordArgs) IsSetReq 

func (p *IClientRPCServiceInsertRecordArgs) IsSetReq() bool

func (*IClientRPCServiceInsertRecordArgs) Read 

func (p *IClientRPCServiceInsertRecordArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordArgs) ReadField1 

func (p *IClientRPCServiceInsertRecordArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordArgs) String 

func (p *IClientRPCServiceInsertRecordArgs) String() string

func (*IClientRPCServiceInsertRecordArgs) Write 

func (p *IClientRPCServiceInsertRecordArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertRecordResult 

type IClientRPCServiceInsertRecordResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceInsertRecordResult 

func NewIClientRPCServiceInsertRecordResult() *IClientRPCServiceInsertRecordResult

func (*IClientRPCServiceInsertRecordResult) GetSuccess 

func (p *IClientRPCServiceInsertRecordResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceInsertRecordResult) IsSetSuccess 

func (p *IClientRPCServiceInsertRecordResult) IsSetSuccess() bool

func (*IClientRPCServiceInsertRecordResult) Read 

func (p *IClientRPCServiceInsertRecordResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordResult) ReadField0 

func (p *IClientRPCServiceInsertRecordResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordResult) String 

func (p *IClientRPCServiceInsertRecordResult) String() string

func (*IClientRPCServiceInsertRecordResult) Write 

func (p *IClientRPCServiceInsertRecordResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertRecordsArgs 

type IClientRPCServiceInsertRecordsArgs struct {
	Req *TSInsertRecordsReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceInsertRecordsArgs 

func NewIClientRPCServiceInsertRecordsArgs() *IClientRPCServiceInsertRecordsArgs

func (*IClientRPCServiceInsertRecordsArgs) GetReq 

func (p *IClientRPCServiceInsertRecordsArgs) GetReq() *TSInsertRecordsReq

func (*IClientRPCServiceInsertRecordsArgs) IsSetReq 

func (p *IClientRPCServiceInsertRecordsArgs) IsSetReq() bool

func (*IClientRPCServiceInsertRecordsArgs) Read 

func (p *IClientRPCServiceInsertRecordsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordsArgs) ReadField1 

func (p *IClientRPCServiceInsertRecordsArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordsArgs) String 

func (p *IClientRPCServiceInsertRecordsArgs) String() string

func (*IClientRPCServiceInsertRecordsArgs) Write 

func (p *IClientRPCServiceInsertRecordsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertRecordsOfOneDeviceArgs 

type IClientRPCServiceInsertRecordsOfOneDeviceArgs struct {
	Req *TSInsertRecordsOfOneDeviceReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceInsertRecordsOfOneDeviceArgs 

func NewIClientRPCServiceInsertRecordsOfOneDeviceArgs() *IClientRPCServiceInsertRecordsOfOneDeviceArgs

func (*IClientRPCServiceInsertRecordsOfOneDeviceArgs) GetReq 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceArgs) GetReq() *TSInsertRecordsOfOneDeviceReq

func (*IClientRPCServiceInsertRecordsOfOneDeviceArgs) IsSetReq 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceArgs) IsSetReq() bool

func (*IClientRPCServiceInsertRecordsOfOneDeviceArgs) Read 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordsOfOneDeviceArgs) ReadField1 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordsOfOneDeviceArgs) String 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceArgs) String() string

func (*IClientRPCServiceInsertRecordsOfOneDeviceArgs) Write 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertRecordsOfOneDeviceResult 

type IClientRPCServiceInsertRecordsOfOneDeviceResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceInsertRecordsOfOneDeviceResult 

func NewIClientRPCServiceInsertRecordsOfOneDeviceResult() *IClientRPCServiceInsertRecordsOfOneDeviceResult

func (*IClientRPCServiceInsertRecordsOfOneDeviceResult) GetSuccess 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceInsertRecordsOfOneDeviceResult) IsSetSuccess 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceResult) IsSetSuccess() bool

func (*IClientRPCServiceInsertRecordsOfOneDeviceResult) Read 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordsOfOneDeviceResult) ReadField0 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordsOfOneDeviceResult) String 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceResult) String() string

func (*IClientRPCServiceInsertRecordsOfOneDeviceResult) Write 

func (p *IClientRPCServiceInsertRecordsOfOneDeviceResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertRecordsResult 

type IClientRPCServiceInsertRecordsResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceInsertRecordsResult 

func NewIClientRPCServiceInsertRecordsResult() *IClientRPCServiceInsertRecordsResult

func (*IClientRPCServiceInsertRecordsResult) GetSuccess 

func (p *IClientRPCServiceInsertRecordsResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceInsertRecordsResult) IsSetSuccess 

func (p *IClientRPCServiceInsertRecordsResult) IsSetSuccess() bool

func (*IClientRPCServiceInsertRecordsResult) Read 

func (p *IClientRPCServiceInsertRecordsResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordsResult) ReadField0 

func (p *IClientRPCServiceInsertRecordsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertRecordsResult) String 

func (p *IClientRPCServiceInsertRecordsResult) String() string

func (*IClientRPCServiceInsertRecordsResult) Write 

func (p *IClientRPCServiceInsertRecordsResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertStringRecordArgs 

type IClientRPCServiceInsertStringRecordArgs struct {
	Req *TSInsertStringRecordReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceInsertStringRecordArgs 

func NewIClientRPCServiceInsertStringRecordArgs() *IClientRPCServiceInsertStringRecordArgs

func (*IClientRPCServiceInsertStringRecordArgs) GetReq 

func (p *IClientRPCServiceInsertStringRecordArgs) GetReq() *TSInsertStringRecordReq

func (*IClientRPCServiceInsertStringRecordArgs) IsSetReq 

func (p *IClientRPCServiceInsertStringRecordArgs) IsSetReq() bool

func (*IClientRPCServiceInsertStringRecordArgs) Read 

func (p *IClientRPCServiceInsertStringRecordArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordArgs) ReadField1 

func (p *IClientRPCServiceInsertStringRecordArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordArgs) String 

func (p *IClientRPCServiceInsertStringRecordArgs) String() string

func (*IClientRPCServiceInsertStringRecordArgs) Write 

func (p *IClientRPCServiceInsertStringRecordArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertStringRecordResult 

type IClientRPCServiceInsertStringRecordResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceInsertStringRecordResult 

func NewIClientRPCServiceInsertStringRecordResult() *IClientRPCServiceInsertStringRecordResult

func (*IClientRPCServiceInsertStringRecordResult) GetSuccess 

func (p *IClientRPCServiceInsertStringRecordResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceInsertStringRecordResult) IsSetSuccess 

func (p *IClientRPCServiceInsertStringRecordResult) IsSetSuccess() bool

func (*IClientRPCServiceInsertStringRecordResult) Read 

func (p *IClientRPCServiceInsertStringRecordResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordResult) ReadField0 

func (p *IClientRPCServiceInsertStringRecordResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordResult) String 

func (p *IClientRPCServiceInsertStringRecordResult) String() string

func (*IClientRPCServiceInsertStringRecordResult) Write 

func (p *IClientRPCServiceInsertStringRecordResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertStringRecordsArgs 

type IClientRPCServiceInsertStringRecordsArgs struct {
	Req *TSInsertStringRecordsReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceInsertStringRecordsArgs 

func NewIClientRPCServiceInsertStringRecordsArgs() *IClientRPCServiceInsertStringRecordsArgs

func (*IClientRPCServiceInsertStringRecordsArgs) GetReq 

func (p *IClientRPCServiceInsertStringRecordsArgs) GetReq() *TSInsertStringRecordsReq

func (*IClientRPCServiceInsertStringRecordsArgs) IsSetReq 

func (p *IClientRPCServiceInsertStringRecordsArgs) IsSetReq() bool

func (*IClientRPCServiceInsertStringRecordsArgs) Read 

func (p *IClientRPCServiceInsertStringRecordsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordsArgs) ReadField1 

func (p *IClientRPCServiceInsertStringRecordsArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordsArgs) String 

func (p *IClientRPCServiceInsertStringRecordsArgs) String() string

func (*IClientRPCServiceInsertStringRecordsArgs) Write 

func (p *IClientRPCServiceInsertStringRecordsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertStringRecordsOfOneDeviceArgs 

type IClientRPCServiceInsertStringRecordsOfOneDeviceArgs struct {
	Req *TSInsertStringRecordsOfOneDeviceReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceInsertStringRecordsOfOneDeviceArgs 

func NewIClientRPCServiceInsertStringRecordsOfOneDeviceArgs() *IClientRPCServiceInsertStringRecordsOfOneDeviceArgs

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) GetReq 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) GetReq() *TSInsertStringRecordsOfOneDeviceReq

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) IsSetReq 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) IsSetReq() bool

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) Read 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) ReadField1 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) String 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) String() string

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) Write 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertStringRecordsOfOneDeviceResult 

type IClientRPCServiceInsertStringRecordsOfOneDeviceResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceInsertStringRecordsOfOneDeviceResult 

func NewIClientRPCServiceInsertStringRecordsOfOneDeviceResult() *IClientRPCServiceInsertStringRecordsOfOneDeviceResult

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceResult) GetSuccess 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceResult) IsSetSuccess 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceResult) IsSetSuccess() bool

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceResult) Read 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceResult) ReadField0 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceResult) String 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceResult) String() string

func (*IClientRPCServiceInsertStringRecordsOfOneDeviceResult) Write 

func (p *IClientRPCServiceInsertStringRecordsOfOneDeviceResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertStringRecordsResult 

type IClientRPCServiceInsertStringRecordsResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceInsertStringRecordsResult 

func NewIClientRPCServiceInsertStringRecordsResult() *IClientRPCServiceInsertStringRecordsResult

func (*IClientRPCServiceInsertStringRecordsResult) GetSuccess 

func (p *IClientRPCServiceInsertStringRecordsResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceInsertStringRecordsResult) IsSetSuccess 

func (p *IClientRPCServiceInsertStringRecordsResult) IsSetSuccess() bool

func (*IClientRPCServiceInsertStringRecordsResult) Read 

func (p *IClientRPCServiceInsertStringRecordsResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordsResult) ReadField0 

func (p *IClientRPCServiceInsertStringRecordsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertStringRecordsResult) String 

func (p *IClientRPCServiceInsertStringRecordsResult) String() string

func (*IClientRPCServiceInsertStringRecordsResult) Write 

func (p *IClientRPCServiceInsertStringRecordsResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertTabletArgs 

type IClientRPCServiceInsertTabletArgs struct {
	Req *TSInsertTabletReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceInsertTabletArgs 

func NewIClientRPCServiceInsertTabletArgs() *IClientRPCServiceInsertTabletArgs

func (*IClientRPCServiceInsertTabletArgs) GetReq 

func (p *IClientRPCServiceInsertTabletArgs) GetReq() *TSInsertTabletReq

func (*IClientRPCServiceInsertTabletArgs) IsSetReq 

func (p *IClientRPCServiceInsertTabletArgs) IsSetReq() bool

func (*IClientRPCServiceInsertTabletArgs) Read 

func (p *IClientRPCServiceInsertTabletArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertTabletArgs) ReadField1 

func (p *IClientRPCServiceInsertTabletArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertTabletArgs) String 

func (p *IClientRPCServiceInsertTabletArgs) String() string

func (*IClientRPCServiceInsertTabletArgs) Write 

func (p *IClientRPCServiceInsertTabletArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertTabletResult 

type IClientRPCServiceInsertTabletResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceInsertTabletResult 

func NewIClientRPCServiceInsertTabletResult() *IClientRPCServiceInsertTabletResult

func (*IClientRPCServiceInsertTabletResult) GetSuccess 

func (p *IClientRPCServiceInsertTabletResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceInsertTabletResult) IsSetSuccess 

func (p *IClientRPCServiceInsertTabletResult) IsSetSuccess() bool

func (*IClientRPCServiceInsertTabletResult) Read 

func (p *IClientRPCServiceInsertTabletResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertTabletResult) ReadField0 

func (p *IClientRPCServiceInsertTabletResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertTabletResult) String 

func (p *IClientRPCServiceInsertTabletResult) String() string

func (*IClientRPCServiceInsertTabletResult) Write 

func (p *IClientRPCServiceInsertTabletResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertTabletsArgs 

type IClientRPCServiceInsertTabletsArgs struct {
	Req *TSInsertTabletsReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceInsertTabletsArgs 

func NewIClientRPCServiceInsertTabletsArgs() *IClientRPCServiceInsertTabletsArgs

func (*IClientRPCServiceInsertTabletsArgs) GetReq 

func (p *IClientRPCServiceInsertTabletsArgs) GetReq() *TSInsertTabletsReq

func (*IClientRPCServiceInsertTabletsArgs) IsSetReq 

func (p *IClientRPCServiceInsertTabletsArgs) IsSetReq() bool

func (*IClientRPCServiceInsertTabletsArgs) Read 

func (p *IClientRPCServiceInsertTabletsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertTabletsArgs) ReadField1 

func (p *IClientRPCServiceInsertTabletsArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertTabletsArgs) String 

func (p *IClientRPCServiceInsertTabletsArgs) String() string

func (*IClientRPCServiceInsertTabletsArgs) Write 

func (p *IClientRPCServiceInsertTabletsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceInsertTabletsResult 

type IClientRPCServiceInsertTabletsResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceInsertTabletsResult 

func NewIClientRPCServiceInsertTabletsResult() *IClientRPCServiceInsertTabletsResult

func (*IClientRPCServiceInsertTabletsResult) GetSuccess 

func (p *IClientRPCServiceInsertTabletsResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceInsertTabletsResult) IsSetSuccess 

func (p *IClientRPCServiceInsertTabletsResult) IsSetSuccess() bool

func (*IClientRPCServiceInsertTabletsResult) Read 

func (p *IClientRPCServiceInsertTabletsResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertTabletsResult) ReadField0 

func (p *IClientRPCServiceInsertTabletsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceInsertTabletsResult) String 

func (p *IClientRPCServiceInsertTabletsResult) String() string

func (*IClientRPCServiceInsertTabletsResult) Write 

func (p *IClientRPCServiceInsertTabletsResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceOpenSessionArgs 

type IClientRPCServiceOpenSessionArgs struct {
	Req *TSOpenSessionReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceOpenSessionArgs 

func NewIClientRPCServiceOpenSessionArgs() *IClientRPCServiceOpenSessionArgs

func (*IClientRPCServiceOpenSessionArgs) GetReq 

func (p *IClientRPCServiceOpenSessionArgs) GetReq() *TSOpenSessionReq

func (*IClientRPCServiceOpenSessionArgs) IsSetReq 

func (p *IClientRPCServiceOpenSessionArgs) IsSetReq() bool

func (*IClientRPCServiceOpenSessionArgs) Read 

func (p *IClientRPCServiceOpenSessionArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceOpenSessionArgs) ReadField1 

func (p *IClientRPCServiceOpenSessionArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceOpenSessionArgs) String 

func (p *IClientRPCServiceOpenSessionArgs) String() string

func (*IClientRPCServiceOpenSessionArgs) Write 

func (p *IClientRPCServiceOpenSessionArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceOpenSessionResult 

type IClientRPCServiceOpenSessionResult struct {
	Success *TSOpenSessionResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceOpenSessionResult 

func NewIClientRPCServiceOpenSessionResult() *IClientRPCServiceOpenSessionResult

func (*IClientRPCServiceOpenSessionResult) GetSuccess 

func (p *IClientRPCServiceOpenSessionResult) GetSuccess() *TSOpenSessionResp

func (*IClientRPCServiceOpenSessionResult) IsSetSuccess 

func (p *IClientRPCServiceOpenSessionResult) IsSetSuccess() bool

func (*IClientRPCServiceOpenSessionResult) Read 

func (p *IClientRPCServiceOpenSessionResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceOpenSessionResult) ReadField0 

func (p *IClientRPCServiceOpenSessionResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceOpenSessionResult) String 

func (p *IClientRPCServiceOpenSessionResult) String() string

func (*IClientRPCServiceOpenSessionResult) Write 

func (p *IClientRPCServiceOpenSessionResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServicePipeSubscribeArgs 

type IClientRPCServicePipeSubscribeArgs struct {
	Req *TPipeSubscribeReq
}

Attributes:

  • Req

func NewIClientRPCServicePipeSubscribeArgs 

func NewIClientRPCServicePipeSubscribeArgs() *IClientRPCServicePipeSubscribeArgs

func (*IClientRPCServicePipeSubscribeArgs) GetReq 

func (p *IClientRPCServicePipeSubscribeArgs) GetReq() *TPipeSubscribeReq

func (*IClientRPCServicePipeSubscribeArgs) IsSetReq 

func (p *IClientRPCServicePipeSubscribeArgs) IsSetReq() bool

func (*IClientRPCServicePipeSubscribeArgs) Read 

func (p *IClientRPCServicePipeSubscribeArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePipeSubscribeArgs) ReadField_1 

func (p *IClientRPCServicePipeSubscribeArgs) ReadField_1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePipeSubscribeArgs) String 

func (p *IClientRPCServicePipeSubscribeArgs) String() string

func (*IClientRPCServicePipeSubscribeArgs) Write 

func (p *IClientRPCServicePipeSubscribeArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServicePipeSubscribeResult 

type IClientRPCServicePipeSubscribeResult struct {
	Success *TPipeSubscribeResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServicePipeSubscribeResult 

func NewIClientRPCServicePipeSubscribeResult() *IClientRPCServicePipeSubscribeResult

func (*IClientRPCServicePipeSubscribeResult) GetSuccess 

func (p *IClientRPCServicePipeSubscribeResult) GetSuccess() *TPipeSubscribeResp

func (*IClientRPCServicePipeSubscribeResult) IsSetSuccess 

func (p *IClientRPCServicePipeSubscribeResult) IsSetSuccess() bool

func (*IClientRPCServicePipeSubscribeResult) Read 

func (p *IClientRPCServicePipeSubscribeResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePipeSubscribeResult) ReadField0 

func (p *IClientRPCServicePipeSubscribeResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePipeSubscribeResult) String 

func (p *IClientRPCServicePipeSubscribeResult) String() string

func (*IClientRPCServicePipeSubscribeResult) Write 

func (p *IClientRPCServicePipeSubscribeResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServicePipeTransferArgs 

type IClientRPCServicePipeTransferArgs struct {
	Req *TPipeTransferReq
}

Attributes:

  • Req

func NewIClientRPCServicePipeTransferArgs 

func NewIClientRPCServicePipeTransferArgs() *IClientRPCServicePipeTransferArgs

func (*IClientRPCServicePipeTransferArgs) GetReq 

func (p *IClientRPCServicePipeTransferArgs) GetReq() *TPipeTransferReq

func (*IClientRPCServicePipeTransferArgs) IsSetReq 

func (p *IClientRPCServicePipeTransferArgs) IsSetReq() bool

func (*IClientRPCServicePipeTransferArgs) Read 

func (p *IClientRPCServicePipeTransferArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePipeTransferArgs) ReadField_1 

func (p *IClientRPCServicePipeTransferArgs) ReadField_1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePipeTransferArgs) String 

func (p *IClientRPCServicePipeTransferArgs) String() string

func (*IClientRPCServicePipeTransferArgs) Write 

func (p *IClientRPCServicePipeTransferArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServicePipeTransferResult 

type IClientRPCServicePipeTransferResult struct {
	Success *TPipeTransferResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServicePipeTransferResult 

func NewIClientRPCServicePipeTransferResult() *IClientRPCServicePipeTransferResult

func (*IClientRPCServicePipeTransferResult) GetSuccess 

func (p *IClientRPCServicePipeTransferResult) GetSuccess() *TPipeTransferResp

func (*IClientRPCServicePipeTransferResult) IsSetSuccess 

func (p *IClientRPCServicePipeTransferResult) IsSetSuccess() bool

func (*IClientRPCServicePipeTransferResult) Read 

func (p *IClientRPCServicePipeTransferResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePipeTransferResult) ReadField0 

func (p *IClientRPCServicePipeTransferResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePipeTransferResult) String 

func (p *IClientRPCServicePipeTransferResult) String() string

func (*IClientRPCServicePipeTransferResult) Write 

func (p *IClientRPCServicePipeTransferResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceProcessor 

type IClientRPCServiceProcessor struct {
	// contains filtered or unexported fields
}

func NewIClientRPCServiceProcessor 

func NewIClientRPCServiceProcessor(handler IClientRPCService) *IClientRPCServiceProcessor

func (*IClientRPCServiceProcessor) AddToProcessorMap 

func (p *IClientRPCServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction)

func (*IClientRPCServiceProcessor) GetProcessorFunction 

func (p *IClientRPCServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool)

func (*IClientRPCServiceProcessor) Process 

func (p *IClientRPCServiceProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException)

func (*IClientRPCServiceProcessor) ProcessorMap 

func (p *IClientRPCServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction

type IClientRPCServicePruneSchemaTemplateArgs 

type IClientRPCServicePruneSchemaTemplateArgs struct {
	Req *TSPruneSchemaTemplateReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServicePruneSchemaTemplateArgs 

func NewIClientRPCServicePruneSchemaTemplateArgs() *IClientRPCServicePruneSchemaTemplateArgs

func (*IClientRPCServicePruneSchemaTemplateArgs) GetReq 

func (p *IClientRPCServicePruneSchemaTemplateArgs) GetReq() *TSPruneSchemaTemplateReq

func (*IClientRPCServicePruneSchemaTemplateArgs) IsSetReq 

func (p *IClientRPCServicePruneSchemaTemplateArgs) IsSetReq() bool

func (*IClientRPCServicePruneSchemaTemplateArgs) Read 

func (p *IClientRPCServicePruneSchemaTemplateArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePruneSchemaTemplateArgs) ReadField1 

func (p *IClientRPCServicePruneSchemaTemplateArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePruneSchemaTemplateArgs) String 

func (p *IClientRPCServicePruneSchemaTemplateArgs) String() string

func (*IClientRPCServicePruneSchemaTemplateArgs) Write 

func (p *IClientRPCServicePruneSchemaTemplateArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServicePruneSchemaTemplateResult 

type IClientRPCServicePruneSchemaTemplateResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServicePruneSchemaTemplateResult 

func NewIClientRPCServicePruneSchemaTemplateResult() *IClientRPCServicePruneSchemaTemplateResult

func (*IClientRPCServicePruneSchemaTemplateResult) GetSuccess 

func (p *IClientRPCServicePruneSchemaTemplateResult) GetSuccess() *common.TSStatus

func (*IClientRPCServicePruneSchemaTemplateResult) IsSetSuccess 

func (p *IClientRPCServicePruneSchemaTemplateResult) IsSetSuccess() bool

func (*IClientRPCServicePruneSchemaTemplateResult) Read 

func (p *IClientRPCServicePruneSchemaTemplateResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePruneSchemaTemplateResult) ReadField0 

func (p *IClientRPCServicePruneSchemaTemplateResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServicePruneSchemaTemplateResult) String 

func (p *IClientRPCServicePruneSchemaTemplateResult) String() string

func (*IClientRPCServicePruneSchemaTemplateResult) Write 

func (p *IClientRPCServicePruneSchemaTemplateResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceQuerySchemaTemplateArgs 

type IClientRPCServiceQuerySchemaTemplateArgs struct {
	Req *TSQueryTemplateReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceQuerySchemaTemplateArgs 

func NewIClientRPCServiceQuerySchemaTemplateArgs() *IClientRPCServiceQuerySchemaTemplateArgs

func (*IClientRPCServiceQuerySchemaTemplateArgs) GetReq 

func (p *IClientRPCServiceQuerySchemaTemplateArgs) GetReq() *TSQueryTemplateReq

func (*IClientRPCServiceQuerySchemaTemplateArgs) IsSetReq 

func (p *IClientRPCServiceQuerySchemaTemplateArgs) IsSetReq() bool

func (*IClientRPCServiceQuerySchemaTemplateArgs) Read 

func (p *IClientRPCServiceQuerySchemaTemplateArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceQuerySchemaTemplateArgs) ReadField1 

func (p *IClientRPCServiceQuerySchemaTemplateArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceQuerySchemaTemplateArgs) String 

func (p *IClientRPCServiceQuerySchemaTemplateArgs) String() string

func (*IClientRPCServiceQuerySchemaTemplateArgs) Write 

func (p *IClientRPCServiceQuerySchemaTemplateArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceQuerySchemaTemplateResult 

type IClientRPCServiceQuerySchemaTemplateResult struct {
	Success *TSQueryTemplateResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceQuerySchemaTemplateResult 

func NewIClientRPCServiceQuerySchemaTemplateResult() *IClientRPCServiceQuerySchemaTemplateResult

func (*IClientRPCServiceQuerySchemaTemplateResult) GetSuccess 

func (p *IClientRPCServiceQuerySchemaTemplateResult) GetSuccess() *TSQueryTemplateResp

func (*IClientRPCServiceQuerySchemaTemplateResult) IsSetSuccess 

func (p *IClientRPCServiceQuerySchemaTemplateResult) IsSetSuccess() bool

func (*IClientRPCServiceQuerySchemaTemplateResult) Read 

func (p *IClientRPCServiceQuerySchemaTemplateResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceQuerySchemaTemplateResult) ReadField0 

func (p *IClientRPCServiceQuerySchemaTemplateResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceQuerySchemaTemplateResult) String 

func (p *IClientRPCServiceQuerySchemaTemplateResult) String() string

func (*IClientRPCServiceQuerySchemaTemplateResult) Write 

func (p *IClientRPCServiceQuerySchemaTemplateResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceRequestStatementIdArgs 

type IClientRPCServiceRequestStatementIdArgs struct {
	SessionId int64 `thrift:"sessionId,1" db:"sessionId" json:"sessionId"`
}

Attributes:

  • SessionId

func NewIClientRPCServiceRequestStatementIdArgs 

func NewIClientRPCServiceRequestStatementIdArgs() *IClientRPCServiceRequestStatementIdArgs

func (*IClientRPCServiceRequestStatementIdArgs) GetSessionId 

func (p *IClientRPCServiceRequestStatementIdArgs) GetSessionId() int64

func (*IClientRPCServiceRequestStatementIdArgs) Read 

func (p *IClientRPCServiceRequestStatementIdArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceRequestStatementIdArgs) ReadField1 

func (p *IClientRPCServiceRequestStatementIdArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceRequestStatementIdArgs) String 

func (p *IClientRPCServiceRequestStatementIdArgs) String() string

func (*IClientRPCServiceRequestStatementIdArgs) Write 

func (p *IClientRPCServiceRequestStatementIdArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceRequestStatementIdResult 

type IClientRPCServiceRequestStatementIdResult struct {
	Success *int64 `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceRequestStatementIdResult 

func NewIClientRPCServiceRequestStatementIdResult() *IClientRPCServiceRequestStatementIdResult

func (*IClientRPCServiceRequestStatementIdResult) GetSuccess 

func (p *IClientRPCServiceRequestStatementIdResult) GetSuccess() int64

func (*IClientRPCServiceRequestStatementIdResult) IsSetSuccess 

func (p *IClientRPCServiceRequestStatementIdResult) IsSetSuccess() bool

func (*IClientRPCServiceRequestStatementIdResult) Read 

func (p *IClientRPCServiceRequestStatementIdResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceRequestStatementIdResult) ReadField0 

func (p *IClientRPCServiceRequestStatementIdResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceRequestStatementIdResult) String 

func (p *IClientRPCServiceRequestStatementIdResult) String() string

func (*IClientRPCServiceRequestStatementIdResult) Write 

func (p *IClientRPCServiceRequestStatementIdResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSendFileArgs 

type IClientRPCServiceSendFileArgs struct {
	MetaInfo *TSyncTransportMetaInfo `thrift:"metaInfo,1" db:"metaInfo" json:"metaInfo"`
	Buff     []byte                  `thrift:"buff,2" db:"buff" json:"buff"`
}

Attributes:

  • MetaInfo
  • Buff

func NewIClientRPCServiceSendFileArgs 

func NewIClientRPCServiceSendFileArgs() *IClientRPCServiceSendFileArgs

func (*IClientRPCServiceSendFileArgs) GetBuff 

func (p *IClientRPCServiceSendFileArgs) GetBuff() []byte

func (*IClientRPCServiceSendFileArgs) GetMetaInfo 

func (p *IClientRPCServiceSendFileArgs) GetMetaInfo() *TSyncTransportMetaInfo

func (*IClientRPCServiceSendFileArgs) IsSetMetaInfo 

func (p *IClientRPCServiceSendFileArgs) IsSetMetaInfo() bool

func (*IClientRPCServiceSendFileArgs) Read 

func (p *IClientRPCServiceSendFileArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSendFileArgs) ReadField1 

func (p *IClientRPCServiceSendFileArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSendFileArgs) ReadField2 

func (p *IClientRPCServiceSendFileArgs) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSendFileArgs) String 

func (p *IClientRPCServiceSendFileArgs) String() string

func (*IClientRPCServiceSendFileArgs) Write 

func (p *IClientRPCServiceSendFileArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSendFileResult 

type IClientRPCServiceSendFileResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceSendFileResult 

func NewIClientRPCServiceSendFileResult() *IClientRPCServiceSendFileResult

func (*IClientRPCServiceSendFileResult) GetSuccess 

func (p *IClientRPCServiceSendFileResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceSendFileResult) IsSetSuccess 

func (p *IClientRPCServiceSendFileResult) IsSetSuccess() bool

func (*IClientRPCServiceSendFileResult) Read 

func (p *IClientRPCServiceSendFileResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSendFileResult) ReadField0 

func (p *IClientRPCServiceSendFileResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSendFileResult) String 

func (p *IClientRPCServiceSendFileResult) String() string

func (*IClientRPCServiceSendFileResult) Write 

func (p *IClientRPCServiceSendFileResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSendPipeDataArgs 

type IClientRPCServiceSendPipeDataArgs struct {
	Buff []byte `thrift:"buff,1" db:"buff" json:"buff"`
}

Attributes:

  • Buff

func NewIClientRPCServiceSendPipeDataArgs 

func NewIClientRPCServiceSendPipeDataArgs() *IClientRPCServiceSendPipeDataArgs

func (*IClientRPCServiceSendPipeDataArgs) GetBuff 

func (p *IClientRPCServiceSendPipeDataArgs) GetBuff() []byte

func (*IClientRPCServiceSendPipeDataArgs) Read 

func (p *IClientRPCServiceSendPipeDataArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSendPipeDataArgs) ReadField1 

func (p *IClientRPCServiceSendPipeDataArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSendPipeDataArgs) String 

func (p *IClientRPCServiceSendPipeDataArgs) String() string

func (*IClientRPCServiceSendPipeDataArgs) Write 

func (p *IClientRPCServiceSendPipeDataArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSendPipeDataResult 

type IClientRPCServiceSendPipeDataResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceSendPipeDataResult 

func NewIClientRPCServiceSendPipeDataResult() *IClientRPCServiceSendPipeDataResult

func (*IClientRPCServiceSendPipeDataResult) GetSuccess 

func (p *IClientRPCServiceSendPipeDataResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceSendPipeDataResult) IsSetSuccess 

func (p *IClientRPCServiceSendPipeDataResult) IsSetSuccess() bool

func (*IClientRPCServiceSendPipeDataResult) Read 

func (p *IClientRPCServiceSendPipeDataResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSendPipeDataResult) ReadField0 

func (p *IClientRPCServiceSendPipeDataResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSendPipeDataResult) String 

func (p *IClientRPCServiceSendPipeDataResult) String() string

func (*IClientRPCServiceSendPipeDataResult) Write 

func (p *IClientRPCServiceSendPipeDataResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSetSchemaTemplateArgs 

type IClientRPCServiceSetSchemaTemplateArgs struct {
	Req *TSSetSchemaTemplateReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceSetSchemaTemplateArgs 

func NewIClientRPCServiceSetSchemaTemplateArgs() *IClientRPCServiceSetSchemaTemplateArgs

func (*IClientRPCServiceSetSchemaTemplateArgs) GetReq 

func (p *IClientRPCServiceSetSchemaTemplateArgs) GetReq() *TSSetSchemaTemplateReq

func (*IClientRPCServiceSetSchemaTemplateArgs) IsSetReq 

func (p *IClientRPCServiceSetSchemaTemplateArgs) IsSetReq() bool

func (*IClientRPCServiceSetSchemaTemplateArgs) Read 

func (p *IClientRPCServiceSetSchemaTemplateArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetSchemaTemplateArgs) ReadField1 

func (p *IClientRPCServiceSetSchemaTemplateArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetSchemaTemplateArgs) String 

func (p *IClientRPCServiceSetSchemaTemplateArgs) String() string

func (*IClientRPCServiceSetSchemaTemplateArgs) Write 

func (p *IClientRPCServiceSetSchemaTemplateArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSetSchemaTemplateResult 

type IClientRPCServiceSetSchemaTemplateResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceSetSchemaTemplateResult 

func NewIClientRPCServiceSetSchemaTemplateResult() *IClientRPCServiceSetSchemaTemplateResult

func (*IClientRPCServiceSetSchemaTemplateResult) GetSuccess 

func (p *IClientRPCServiceSetSchemaTemplateResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceSetSchemaTemplateResult) IsSetSuccess 

func (p *IClientRPCServiceSetSchemaTemplateResult) IsSetSuccess() bool

func (*IClientRPCServiceSetSchemaTemplateResult) Read 

func (p *IClientRPCServiceSetSchemaTemplateResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetSchemaTemplateResult) ReadField0 

func (p *IClientRPCServiceSetSchemaTemplateResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetSchemaTemplateResult) String 

func (p *IClientRPCServiceSetSchemaTemplateResult) String() string

func (*IClientRPCServiceSetSchemaTemplateResult) Write 

func (p *IClientRPCServiceSetSchemaTemplateResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSetStorageGroupArgs 

type IClientRPCServiceSetStorageGroupArgs struct {
	SessionId    int64  `thrift:"sessionId,1" db:"sessionId" json:"sessionId"`
	StorageGroup string `thrift:"storageGroup,2" db:"storageGroup" json:"storageGroup"`
}

Attributes:

  • SessionId
  • StorageGroup

func NewIClientRPCServiceSetStorageGroupArgs 

func NewIClientRPCServiceSetStorageGroupArgs() *IClientRPCServiceSetStorageGroupArgs

func (*IClientRPCServiceSetStorageGroupArgs) GetSessionId 

func (p *IClientRPCServiceSetStorageGroupArgs) GetSessionId() int64

func (*IClientRPCServiceSetStorageGroupArgs) GetStorageGroup 

func (p *IClientRPCServiceSetStorageGroupArgs) GetStorageGroup() string

func (*IClientRPCServiceSetStorageGroupArgs) Read 

func (p *IClientRPCServiceSetStorageGroupArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetStorageGroupArgs) ReadField1 

func (p *IClientRPCServiceSetStorageGroupArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetStorageGroupArgs) ReadField2 

func (p *IClientRPCServiceSetStorageGroupArgs) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetStorageGroupArgs) String 

func (p *IClientRPCServiceSetStorageGroupArgs) String() string

func (*IClientRPCServiceSetStorageGroupArgs) Write 

func (p *IClientRPCServiceSetStorageGroupArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSetStorageGroupResult 

type IClientRPCServiceSetStorageGroupResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceSetStorageGroupResult 

func NewIClientRPCServiceSetStorageGroupResult() *IClientRPCServiceSetStorageGroupResult

func (*IClientRPCServiceSetStorageGroupResult) GetSuccess 

func (p *IClientRPCServiceSetStorageGroupResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceSetStorageGroupResult) IsSetSuccess 

func (p *IClientRPCServiceSetStorageGroupResult) IsSetSuccess() bool

func (*IClientRPCServiceSetStorageGroupResult) Read 

func (p *IClientRPCServiceSetStorageGroupResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetStorageGroupResult) ReadField0 

func (p *IClientRPCServiceSetStorageGroupResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetStorageGroupResult) String 

func (p *IClientRPCServiceSetStorageGroupResult) String() string

func (*IClientRPCServiceSetStorageGroupResult) Write 

func (p *IClientRPCServiceSetStorageGroupResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSetTimeZoneArgs 

type IClientRPCServiceSetTimeZoneArgs struct {
	Req *TSSetTimeZoneReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceSetTimeZoneArgs 

func NewIClientRPCServiceSetTimeZoneArgs() *IClientRPCServiceSetTimeZoneArgs

func (*IClientRPCServiceSetTimeZoneArgs) GetReq 

func (p *IClientRPCServiceSetTimeZoneArgs) GetReq() *TSSetTimeZoneReq

func (*IClientRPCServiceSetTimeZoneArgs) IsSetReq 

func (p *IClientRPCServiceSetTimeZoneArgs) IsSetReq() bool

func (*IClientRPCServiceSetTimeZoneArgs) Read 

func (p *IClientRPCServiceSetTimeZoneArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetTimeZoneArgs) ReadField1 

func (p *IClientRPCServiceSetTimeZoneArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetTimeZoneArgs) String 

func (p *IClientRPCServiceSetTimeZoneArgs) String() string

func (*IClientRPCServiceSetTimeZoneArgs) Write 

func (p *IClientRPCServiceSetTimeZoneArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceSetTimeZoneResult 

type IClientRPCServiceSetTimeZoneResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceSetTimeZoneResult 

func NewIClientRPCServiceSetTimeZoneResult() *IClientRPCServiceSetTimeZoneResult

func (*IClientRPCServiceSetTimeZoneResult) GetSuccess 

func (p *IClientRPCServiceSetTimeZoneResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceSetTimeZoneResult) IsSetSuccess 

func (p *IClientRPCServiceSetTimeZoneResult) IsSetSuccess() bool

func (*IClientRPCServiceSetTimeZoneResult) Read 

func (p *IClientRPCServiceSetTimeZoneResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetTimeZoneResult) ReadField0 

func (p *IClientRPCServiceSetTimeZoneResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceSetTimeZoneResult) String 

func (p *IClientRPCServiceSetTimeZoneResult) String() string

func (*IClientRPCServiceSetTimeZoneResult) Write 

func (p *IClientRPCServiceSetTimeZoneResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceShowConfigurationArgs 

type IClientRPCServiceShowConfigurationArgs struct {
	NodeId int32 `thrift:"nodeId,1" db:"nodeId" json:"nodeId"`
}

Attributes:

  • NodeId

func NewIClientRPCServiceShowConfigurationArgs 

func NewIClientRPCServiceShowConfigurationArgs() *IClientRPCServiceShowConfigurationArgs

func (*IClientRPCServiceShowConfigurationArgs) GetNodeId 

func (p *IClientRPCServiceShowConfigurationArgs) GetNodeId() int32

func (*IClientRPCServiceShowConfigurationArgs) Read 

func (p *IClientRPCServiceShowConfigurationArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceShowConfigurationArgs) ReadField1 

func (p *IClientRPCServiceShowConfigurationArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceShowConfigurationArgs) String 

func (p *IClientRPCServiceShowConfigurationArgs) String() string

func (*IClientRPCServiceShowConfigurationArgs) Write 

func (p *IClientRPCServiceShowConfigurationArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceShowConfigurationResult 

type IClientRPCServiceShowConfigurationResult struct {
	Success *common.TShowConfigurationResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceShowConfigurationResult 

func NewIClientRPCServiceShowConfigurationResult() *IClientRPCServiceShowConfigurationResult

func (*IClientRPCServiceShowConfigurationResult) GetSuccess 

func (p *IClientRPCServiceShowConfigurationResult) GetSuccess() *common.TShowConfigurationResp

func (*IClientRPCServiceShowConfigurationResult) IsSetSuccess 

func (p *IClientRPCServiceShowConfigurationResult) IsSetSuccess() bool

func (*IClientRPCServiceShowConfigurationResult) Read 

func (p *IClientRPCServiceShowConfigurationResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceShowConfigurationResult) ReadField0 

func (p *IClientRPCServiceShowConfigurationResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceShowConfigurationResult) String 

func (p *IClientRPCServiceShowConfigurationResult) String() string

func (*IClientRPCServiceShowConfigurationResult) Write 

func (p *IClientRPCServiceShowConfigurationResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceShowConfigurationTemplateArgs 

type IClientRPCServiceShowConfigurationTemplateArgs struct {
}

func NewIClientRPCServiceShowConfigurationTemplateArgs 

func NewIClientRPCServiceShowConfigurationTemplateArgs() *IClientRPCServiceShowConfigurationTemplateArgs

func (*IClientRPCServiceShowConfigurationTemplateArgs) Read 

func (p *IClientRPCServiceShowConfigurationTemplateArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceShowConfigurationTemplateArgs) String 

func (p *IClientRPCServiceShowConfigurationTemplateArgs) String() string

func (*IClientRPCServiceShowConfigurationTemplateArgs) Write 

func (p *IClientRPCServiceShowConfigurationTemplateArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceShowConfigurationTemplateResult 

type IClientRPCServiceShowConfigurationTemplateResult struct {
	Success *common.TShowConfigurationTemplateResp `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceShowConfigurationTemplateResult 

func NewIClientRPCServiceShowConfigurationTemplateResult() *IClientRPCServiceShowConfigurationTemplateResult

func (*IClientRPCServiceShowConfigurationTemplateResult) GetSuccess 

func (p *IClientRPCServiceShowConfigurationTemplateResult) GetSuccess() *common.TShowConfigurationTemplateResp

func (*IClientRPCServiceShowConfigurationTemplateResult) IsSetSuccess 

func (p *IClientRPCServiceShowConfigurationTemplateResult) IsSetSuccess() bool

func (*IClientRPCServiceShowConfigurationTemplateResult) Read 

func (p *IClientRPCServiceShowConfigurationTemplateResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceShowConfigurationTemplateResult) ReadField0 

func (p *IClientRPCServiceShowConfigurationTemplateResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceShowConfigurationTemplateResult) String 

func (p *IClientRPCServiceShowConfigurationTemplateResult) String() string

func (*IClientRPCServiceShowConfigurationTemplateResult) Write 

func (p *IClientRPCServiceShowConfigurationTemplateResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestConnectionEmptyRPCArgs 

type IClientRPCServiceTestConnectionEmptyRPCArgs struct {
}

func NewIClientRPCServiceTestConnectionEmptyRPCArgs 

func NewIClientRPCServiceTestConnectionEmptyRPCArgs() *IClientRPCServiceTestConnectionEmptyRPCArgs

func (*IClientRPCServiceTestConnectionEmptyRPCArgs) Read 

func (p *IClientRPCServiceTestConnectionEmptyRPCArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestConnectionEmptyRPCArgs) String 

func (p *IClientRPCServiceTestConnectionEmptyRPCArgs) String() string

func (*IClientRPCServiceTestConnectionEmptyRPCArgs) Write 

func (p *IClientRPCServiceTestConnectionEmptyRPCArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestConnectionEmptyRPCResult 

type IClientRPCServiceTestConnectionEmptyRPCResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceTestConnectionEmptyRPCResult 

func NewIClientRPCServiceTestConnectionEmptyRPCResult() *IClientRPCServiceTestConnectionEmptyRPCResult

func (*IClientRPCServiceTestConnectionEmptyRPCResult) GetSuccess 

func (p *IClientRPCServiceTestConnectionEmptyRPCResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceTestConnectionEmptyRPCResult) IsSetSuccess 

func (p *IClientRPCServiceTestConnectionEmptyRPCResult) IsSetSuccess() bool

func (*IClientRPCServiceTestConnectionEmptyRPCResult) Read 

func (p *IClientRPCServiceTestConnectionEmptyRPCResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestConnectionEmptyRPCResult) ReadField0 

func (p *IClientRPCServiceTestConnectionEmptyRPCResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestConnectionEmptyRPCResult) String 

func (p *IClientRPCServiceTestConnectionEmptyRPCResult) String() string

func (*IClientRPCServiceTestConnectionEmptyRPCResult) Write 

func (p *IClientRPCServiceTestConnectionEmptyRPCResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertRecordArgs 

type IClientRPCServiceTestInsertRecordArgs struct {
	Req *TSInsertRecordReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceTestInsertRecordArgs 

func NewIClientRPCServiceTestInsertRecordArgs() *IClientRPCServiceTestInsertRecordArgs

func (*IClientRPCServiceTestInsertRecordArgs) GetReq 

func (p *IClientRPCServiceTestInsertRecordArgs) GetReq() *TSInsertRecordReq

func (*IClientRPCServiceTestInsertRecordArgs) IsSetReq 

func (p *IClientRPCServiceTestInsertRecordArgs) IsSetReq() bool

func (*IClientRPCServiceTestInsertRecordArgs) Read 

func (p *IClientRPCServiceTestInsertRecordArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordArgs) ReadField1 

func (p *IClientRPCServiceTestInsertRecordArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordArgs) String 

func (p *IClientRPCServiceTestInsertRecordArgs) String() string

func (*IClientRPCServiceTestInsertRecordArgs) Write 

func (p *IClientRPCServiceTestInsertRecordArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertRecordResult 

type IClientRPCServiceTestInsertRecordResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceTestInsertRecordResult 

func NewIClientRPCServiceTestInsertRecordResult() *IClientRPCServiceTestInsertRecordResult

func (*IClientRPCServiceTestInsertRecordResult) GetSuccess 

func (p *IClientRPCServiceTestInsertRecordResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceTestInsertRecordResult) IsSetSuccess 

func (p *IClientRPCServiceTestInsertRecordResult) IsSetSuccess() bool

func (*IClientRPCServiceTestInsertRecordResult) Read 

func (p *IClientRPCServiceTestInsertRecordResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordResult) ReadField0 

func (p *IClientRPCServiceTestInsertRecordResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordResult) String 

func (p *IClientRPCServiceTestInsertRecordResult) String() string

func (*IClientRPCServiceTestInsertRecordResult) Write 

func (p *IClientRPCServiceTestInsertRecordResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertRecordsArgs 

type IClientRPCServiceTestInsertRecordsArgs struct {
	Req *TSInsertRecordsReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceTestInsertRecordsArgs 

func NewIClientRPCServiceTestInsertRecordsArgs() *IClientRPCServiceTestInsertRecordsArgs

func (*IClientRPCServiceTestInsertRecordsArgs) GetReq 

func (p *IClientRPCServiceTestInsertRecordsArgs) GetReq() *TSInsertRecordsReq

func (*IClientRPCServiceTestInsertRecordsArgs) IsSetReq 

func (p *IClientRPCServiceTestInsertRecordsArgs) IsSetReq() bool

func (*IClientRPCServiceTestInsertRecordsArgs) Read 

func (p *IClientRPCServiceTestInsertRecordsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordsArgs) ReadField1 

func (p *IClientRPCServiceTestInsertRecordsArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordsArgs) String 

func (p *IClientRPCServiceTestInsertRecordsArgs) String() string

func (*IClientRPCServiceTestInsertRecordsArgs) Write 

func (p *IClientRPCServiceTestInsertRecordsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertRecordsOfOneDeviceArgs 

type IClientRPCServiceTestInsertRecordsOfOneDeviceArgs struct {
	Req *TSInsertRecordsOfOneDeviceReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceTestInsertRecordsOfOneDeviceArgs 

func NewIClientRPCServiceTestInsertRecordsOfOneDeviceArgs() *IClientRPCServiceTestInsertRecordsOfOneDeviceArgs

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) GetReq 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) GetReq() *TSInsertRecordsOfOneDeviceReq

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) IsSetReq 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) IsSetReq() bool

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) Read 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) ReadField1 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) String 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) String() string

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) Write 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertRecordsOfOneDeviceResult 

type IClientRPCServiceTestInsertRecordsOfOneDeviceResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceTestInsertRecordsOfOneDeviceResult 

func NewIClientRPCServiceTestInsertRecordsOfOneDeviceResult() *IClientRPCServiceTestInsertRecordsOfOneDeviceResult

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceResult) GetSuccess 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceResult) IsSetSuccess 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceResult) IsSetSuccess() bool

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceResult) Read 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceResult) ReadField0 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceResult) String 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceResult) String() string

func (*IClientRPCServiceTestInsertRecordsOfOneDeviceResult) Write 

func (p *IClientRPCServiceTestInsertRecordsOfOneDeviceResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertRecordsResult 

type IClientRPCServiceTestInsertRecordsResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceTestInsertRecordsResult 

func NewIClientRPCServiceTestInsertRecordsResult() *IClientRPCServiceTestInsertRecordsResult

func (*IClientRPCServiceTestInsertRecordsResult) GetSuccess 

func (p *IClientRPCServiceTestInsertRecordsResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceTestInsertRecordsResult) IsSetSuccess 

func (p *IClientRPCServiceTestInsertRecordsResult) IsSetSuccess() bool

func (*IClientRPCServiceTestInsertRecordsResult) Read 

func (p *IClientRPCServiceTestInsertRecordsResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordsResult) ReadField0 

func (p *IClientRPCServiceTestInsertRecordsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertRecordsResult) String 

func (p *IClientRPCServiceTestInsertRecordsResult) String() string

func (*IClientRPCServiceTestInsertRecordsResult) Write 

func (p *IClientRPCServiceTestInsertRecordsResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertStringRecordArgs 

type IClientRPCServiceTestInsertStringRecordArgs struct {
	Req *TSInsertStringRecordReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceTestInsertStringRecordArgs 

func NewIClientRPCServiceTestInsertStringRecordArgs() *IClientRPCServiceTestInsertStringRecordArgs

func (*IClientRPCServiceTestInsertStringRecordArgs) GetReq 

func (p *IClientRPCServiceTestInsertStringRecordArgs) GetReq() *TSInsertStringRecordReq

func (*IClientRPCServiceTestInsertStringRecordArgs) IsSetReq 

func (p *IClientRPCServiceTestInsertStringRecordArgs) IsSetReq() bool

func (*IClientRPCServiceTestInsertStringRecordArgs) Read 

func (p *IClientRPCServiceTestInsertStringRecordArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertStringRecordArgs) ReadField1 

func (p *IClientRPCServiceTestInsertStringRecordArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertStringRecordArgs) String 

func (p *IClientRPCServiceTestInsertStringRecordArgs) String() string

func (*IClientRPCServiceTestInsertStringRecordArgs) Write 

func (p *IClientRPCServiceTestInsertStringRecordArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertStringRecordResult 

type IClientRPCServiceTestInsertStringRecordResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceTestInsertStringRecordResult 

func NewIClientRPCServiceTestInsertStringRecordResult() *IClientRPCServiceTestInsertStringRecordResult

func (*IClientRPCServiceTestInsertStringRecordResult) GetSuccess 

func (p *IClientRPCServiceTestInsertStringRecordResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceTestInsertStringRecordResult) IsSetSuccess 

func (p *IClientRPCServiceTestInsertStringRecordResult) IsSetSuccess() bool

func (*IClientRPCServiceTestInsertStringRecordResult) Read 

func (p *IClientRPCServiceTestInsertStringRecordResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertStringRecordResult) ReadField0 

func (p *IClientRPCServiceTestInsertStringRecordResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertStringRecordResult) String 

func (p *IClientRPCServiceTestInsertStringRecordResult) String() string

func (*IClientRPCServiceTestInsertStringRecordResult) Write 

func (p *IClientRPCServiceTestInsertStringRecordResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertStringRecordsArgs 

type IClientRPCServiceTestInsertStringRecordsArgs struct {
	Req *TSInsertStringRecordsReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceTestInsertStringRecordsArgs 

func NewIClientRPCServiceTestInsertStringRecordsArgs() *IClientRPCServiceTestInsertStringRecordsArgs

func (*IClientRPCServiceTestInsertStringRecordsArgs) GetReq 

func (p *IClientRPCServiceTestInsertStringRecordsArgs) GetReq() *TSInsertStringRecordsReq

func (*IClientRPCServiceTestInsertStringRecordsArgs) IsSetReq 

func (p *IClientRPCServiceTestInsertStringRecordsArgs) IsSetReq() bool

func (*IClientRPCServiceTestInsertStringRecordsArgs) Read 

func (p *IClientRPCServiceTestInsertStringRecordsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertStringRecordsArgs) ReadField1 

func (p *IClientRPCServiceTestInsertStringRecordsArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertStringRecordsArgs) String 

func (p *IClientRPCServiceTestInsertStringRecordsArgs) String() string

func (*IClientRPCServiceTestInsertStringRecordsArgs) Write 

func (p *IClientRPCServiceTestInsertStringRecordsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertStringRecordsResult 

type IClientRPCServiceTestInsertStringRecordsResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceTestInsertStringRecordsResult 

func NewIClientRPCServiceTestInsertStringRecordsResult() *IClientRPCServiceTestInsertStringRecordsResult

func (*IClientRPCServiceTestInsertStringRecordsResult) GetSuccess 

func (p *IClientRPCServiceTestInsertStringRecordsResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceTestInsertStringRecordsResult) IsSetSuccess 

func (p *IClientRPCServiceTestInsertStringRecordsResult) IsSetSuccess() bool

func (*IClientRPCServiceTestInsertStringRecordsResult) Read 

func (p *IClientRPCServiceTestInsertStringRecordsResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertStringRecordsResult) ReadField0 

func (p *IClientRPCServiceTestInsertStringRecordsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertStringRecordsResult) String 

func (p *IClientRPCServiceTestInsertStringRecordsResult) String() string

func (*IClientRPCServiceTestInsertStringRecordsResult) Write 

func (p *IClientRPCServiceTestInsertStringRecordsResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertTabletArgs 

type IClientRPCServiceTestInsertTabletArgs struct {
	Req *TSInsertTabletReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceTestInsertTabletArgs 

func NewIClientRPCServiceTestInsertTabletArgs() *IClientRPCServiceTestInsertTabletArgs

func (*IClientRPCServiceTestInsertTabletArgs) GetReq 

func (p *IClientRPCServiceTestInsertTabletArgs) GetReq() *TSInsertTabletReq

func (*IClientRPCServiceTestInsertTabletArgs) IsSetReq 

func (p *IClientRPCServiceTestInsertTabletArgs) IsSetReq() bool

func (*IClientRPCServiceTestInsertTabletArgs) Read 

func (p *IClientRPCServiceTestInsertTabletArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertTabletArgs) ReadField1 

func (p *IClientRPCServiceTestInsertTabletArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertTabletArgs) String 

func (p *IClientRPCServiceTestInsertTabletArgs) String() string

func (*IClientRPCServiceTestInsertTabletArgs) Write 

func (p *IClientRPCServiceTestInsertTabletArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertTabletResult 

type IClientRPCServiceTestInsertTabletResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceTestInsertTabletResult 

func NewIClientRPCServiceTestInsertTabletResult() *IClientRPCServiceTestInsertTabletResult

func (*IClientRPCServiceTestInsertTabletResult) GetSuccess 

func (p *IClientRPCServiceTestInsertTabletResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceTestInsertTabletResult) IsSetSuccess 

func (p *IClientRPCServiceTestInsertTabletResult) IsSetSuccess() bool

func (*IClientRPCServiceTestInsertTabletResult) Read 

func (p *IClientRPCServiceTestInsertTabletResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertTabletResult) ReadField0 

func (p *IClientRPCServiceTestInsertTabletResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertTabletResult) String 

func (p *IClientRPCServiceTestInsertTabletResult) String() string

func (*IClientRPCServiceTestInsertTabletResult) Write 

func (p *IClientRPCServiceTestInsertTabletResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertTabletsArgs 

type IClientRPCServiceTestInsertTabletsArgs struct {
	Req *TSInsertTabletsReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceTestInsertTabletsArgs 

func NewIClientRPCServiceTestInsertTabletsArgs() *IClientRPCServiceTestInsertTabletsArgs

func (*IClientRPCServiceTestInsertTabletsArgs) GetReq 

func (p *IClientRPCServiceTestInsertTabletsArgs) GetReq() *TSInsertTabletsReq

func (*IClientRPCServiceTestInsertTabletsArgs) IsSetReq 

func (p *IClientRPCServiceTestInsertTabletsArgs) IsSetReq() bool

func (*IClientRPCServiceTestInsertTabletsArgs) Read 

func (p *IClientRPCServiceTestInsertTabletsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertTabletsArgs) ReadField1 

func (p *IClientRPCServiceTestInsertTabletsArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertTabletsArgs) String 

func (p *IClientRPCServiceTestInsertTabletsArgs) String() string

func (*IClientRPCServiceTestInsertTabletsArgs) Write 

func (p *IClientRPCServiceTestInsertTabletsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceTestInsertTabletsResult 

type IClientRPCServiceTestInsertTabletsResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceTestInsertTabletsResult 

func NewIClientRPCServiceTestInsertTabletsResult() *IClientRPCServiceTestInsertTabletsResult

func (*IClientRPCServiceTestInsertTabletsResult) GetSuccess 

func (p *IClientRPCServiceTestInsertTabletsResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceTestInsertTabletsResult) IsSetSuccess 

func (p *IClientRPCServiceTestInsertTabletsResult) IsSetSuccess() bool

func (*IClientRPCServiceTestInsertTabletsResult) Read 

func (p *IClientRPCServiceTestInsertTabletsResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertTabletsResult) ReadField0 

func (p *IClientRPCServiceTestInsertTabletsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceTestInsertTabletsResult) String 

func (p *IClientRPCServiceTestInsertTabletsResult) String() string

func (*IClientRPCServiceTestInsertTabletsResult) Write 

func (p *IClientRPCServiceTestInsertTabletsResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceUnsetSchemaTemplateArgs 

type IClientRPCServiceUnsetSchemaTemplateArgs struct {
	Req *TSUnsetSchemaTemplateReq `thrift:"req,1" db:"req" json:"req"`
}

Attributes:

  • Req

func NewIClientRPCServiceUnsetSchemaTemplateArgs 

func NewIClientRPCServiceUnsetSchemaTemplateArgs() *IClientRPCServiceUnsetSchemaTemplateArgs

func (*IClientRPCServiceUnsetSchemaTemplateArgs) GetReq 

func (p *IClientRPCServiceUnsetSchemaTemplateArgs) GetReq() *TSUnsetSchemaTemplateReq

func (*IClientRPCServiceUnsetSchemaTemplateArgs) IsSetReq 

func (p *IClientRPCServiceUnsetSchemaTemplateArgs) IsSetReq() bool

func (*IClientRPCServiceUnsetSchemaTemplateArgs) Read 

func (p *IClientRPCServiceUnsetSchemaTemplateArgs) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceUnsetSchemaTemplateArgs) ReadField1 

func (p *IClientRPCServiceUnsetSchemaTemplateArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceUnsetSchemaTemplateArgs) String 

func (p *IClientRPCServiceUnsetSchemaTemplateArgs) String() string

func (*IClientRPCServiceUnsetSchemaTemplateArgs) Write 

func (p *IClientRPCServiceUnsetSchemaTemplateArgs) Write(ctx context.Context, oprot thrift.TProtocol) error

type IClientRPCServiceUnsetSchemaTemplateResult 

type IClientRPCServiceUnsetSchemaTemplateResult struct {
	Success *common.TSStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

Attributes:

  • Success

func NewIClientRPCServiceUnsetSchemaTemplateResult 

func NewIClientRPCServiceUnsetSchemaTemplateResult() *IClientRPCServiceUnsetSchemaTemplateResult

func (*IClientRPCServiceUnsetSchemaTemplateResult) GetSuccess 

func (p *IClientRPCServiceUnsetSchemaTemplateResult) GetSuccess() *common.TSStatus

func (*IClientRPCServiceUnsetSchemaTemplateResult) IsSetSuccess 

func (p *IClientRPCServiceUnsetSchemaTemplateResult) IsSetSuccess() bool

func (*IClientRPCServiceUnsetSchemaTemplateResult) Read 

func (p *IClientRPCServiceUnsetSchemaTemplateResult) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceUnsetSchemaTemplateResult) ReadField0 

func (p *IClientRPCServiceUnsetSchemaTemplateResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error

func (*IClientRPCServiceUnsetSchemaTemplateResult) String 

func (p *IClientRPCServiceUnsetSchemaTemplateResult) String() string

func (*IClientRPCServiceUnsetSchemaTemplateResult) Write 

func (p *IClientRPCServiceUnsetSchemaTemplateResult) Write(ctx context.Context, oprot thrift.TProtocol) error

type ServerProperties 

type ServerProperties struct {
	Version                            string   `thrift:"version,1,required" db:"version" json:"version"`
	SupportedTimeAggregationOperations []string `` /* 136-byte string literal not displayed */
	TimestampPrecision                 string   `thrift:"timestampPrecision,3,required" db:"timestampPrecision" json:"timestampPrecision"`
	MaxConcurrentClientNum             int32    `thrift:"maxConcurrentClientNum,4" db:"maxConcurrentClientNum" json:"maxConcurrentClientNum"`
	ThriftMaxFrameSize                 *int32   `thrift:"thriftMaxFrameSize,5" db:"thriftMaxFrameSize" json:"thriftMaxFrameSize,omitempty"`
	IsReadOnly                         *bool    `thrift:"isReadOnly,6" db:"isReadOnly" json:"isReadOnly,omitempty"`
	BuildInfo                          *string  `thrift:"buildInfo,7" db:"buildInfo" json:"buildInfo,omitempty"`
}

Attributes:

  • Version
  • SupportedTimeAggregationOperations
  • TimestampPrecision
  • MaxConcurrentClientNum
  • ThriftMaxFrameSize
  • IsReadOnly
  • BuildInfo
  • Logo
var IClientRPCServiceGetPropertiesResult_Success_DEFAULT *ServerProperties

func NewServerProperties 

func NewServerProperties() *ServerProperties

func (*ServerProperties) Equals 

func (p *ServerProperties) Equals(other *ServerProperties) bool

func (*ServerProperties) GetBuildInfo 

func (p *ServerProperties) GetBuildInfo() string

func (*ServerProperties) GetIsReadOnly 

func (p *ServerProperties) GetIsReadOnly() bool
func (p *ServerProperties) GetLogo() string

func (*ServerProperties) GetMaxConcurrentClientNum 

func (p *ServerProperties) GetMaxConcurrentClientNum() int32

func (*ServerProperties) GetSupportedTimeAggregationOperations 

func (p *ServerProperties) GetSupportedTimeAggregationOperations() []string

func (*ServerProperties) GetThriftMaxFrameSize 

func (p *ServerProperties) GetThriftMaxFrameSize() int32

func (*ServerProperties) GetTimestampPrecision 

func (p *ServerProperties) GetTimestampPrecision() string

func (*ServerProperties) GetVersion 

func (p *ServerProperties) GetVersion() string

func (*ServerProperties) IsSetBuildInfo 

func (p *ServerProperties) IsSetBuildInfo() bool

func (*ServerProperties) IsSetIsReadOnly 

func (p *ServerProperties) IsSetIsReadOnly() bool
func (p *ServerProperties) IsSetLogo() bool

func (*ServerProperties) IsSetThriftMaxFrameSize 

func (p *ServerProperties) IsSetThriftMaxFrameSize() bool

func (*ServerProperties) Read 

func (p *ServerProperties) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*ServerProperties) ReadField1 

func (p *ServerProperties) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*ServerProperties) ReadField2 

func (p *ServerProperties) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*ServerProperties) ReadField3 

func (p *ServerProperties) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*ServerProperties) ReadField4 

func (p *ServerProperties) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*ServerProperties) ReadField5 

func (p *ServerProperties) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*ServerProperties) ReadField6 

func (p *ServerProperties) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*ServerProperties) ReadField7 

func (p *ServerProperties) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*ServerProperties) ReadField8 

func (p *ServerProperties) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*ServerProperties) String 

func (p *ServerProperties) String() string

func (*ServerProperties) Write 

func (p *ServerProperties) Write(ctx context.Context, oprot thrift.TProtocol) error

type TCreateTimeseriesUsingSchemaTemplateReq 

type TCreateTimeseriesUsingSchemaTemplateReq struct {
	SessionId      int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	DevicePathList []string `thrift:"devicePathList,2,required" db:"devicePathList" json:"devicePathList"`
}

Attributes:

  • SessionId
  • DevicePathList
var IClientRPCServiceCreateTimeseriesUsingSchemaTemplateArgs_Req_DEFAULT *TCreateTimeseriesUsingSchemaTemplateReq

func NewTCreateTimeseriesUsingSchemaTemplateReq 

func NewTCreateTimeseriesUsingSchemaTemplateReq() *TCreateTimeseriesUsingSchemaTemplateReq

func (*TCreateTimeseriesUsingSchemaTemplateReq) Equals 

func (p *TCreateTimeseriesUsingSchemaTemplateReq) Equals(other *TCreateTimeseriesUsingSchemaTemplateReq) bool

func (*TCreateTimeseriesUsingSchemaTemplateReq) GetDevicePathList 

func (p *TCreateTimeseriesUsingSchemaTemplateReq) GetDevicePathList() []string

func (*TCreateTimeseriesUsingSchemaTemplateReq) GetSessionId 

func (p *TCreateTimeseriesUsingSchemaTemplateReq) GetSessionId() int64

func (*TCreateTimeseriesUsingSchemaTemplateReq) Read 

func (p *TCreateTimeseriesUsingSchemaTemplateReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TCreateTimeseriesUsingSchemaTemplateReq) ReadField1 

func (p *TCreateTimeseriesUsingSchemaTemplateReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TCreateTimeseriesUsingSchemaTemplateReq) ReadField2 

func (p *TCreateTimeseriesUsingSchemaTemplateReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TCreateTimeseriesUsingSchemaTemplateReq) String 

func (p *TCreateTimeseriesUsingSchemaTemplateReq) String() string

func (*TCreateTimeseriesUsingSchemaTemplateReq) Write 

func (p *TCreateTimeseriesUsingSchemaTemplateReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TPipeSubscribeReq 

type TPipeSubscribeReq struct {
	Version int8   `thrift:"version,1,required" db:"version" json:"version"`
	Type    int16  `thrift:"type,2,required" db:"type" json:"type"`
	Body    []byte `thrift:"body,3" db:"body" json:"body,omitempty"`
}

Attributes:

  • Version
  • Type
  • Body
var IClientRPCServicePipeSubscribeArgs_Req_DEFAULT *TPipeSubscribeReq

func NewTPipeSubscribeReq 

func NewTPipeSubscribeReq() *TPipeSubscribeReq

func (*TPipeSubscribeReq) Equals 

func (p *TPipeSubscribeReq) Equals(other *TPipeSubscribeReq) bool

func (*TPipeSubscribeReq) GetBody 

func (p *TPipeSubscribeReq) GetBody() []byte

func (*TPipeSubscribeReq) GetType 

func (p *TPipeSubscribeReq) GetType() int16

func (*TPipeSubscribeReq) GetVersion 

func (p *TPipeSubscribeReq) GetVersion() int8

func (*TPipeSubscribeReq) IsSetBody 

func (p *TPipeSubscribeReq) IsSetBody() bool

func (*TPipeSubscribeReq) Read 

func (p *TPipeSubscribeReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeSubscribeReq) ReadField1 

func (p *TPipeSubscribeReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeSubscribeReq) ReadField2 

func (p *TPipeSubscribeReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeSubscribeReq) ReadField3 

func (p *TPipeSubscribeReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeSubscribeReq) String 

func (p *TPipeSubscribeReq) String() string

func (*TPipeSubscribeReq) Write 

func (p *TPipeSubscribeReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TPipeSubscribeResp 

type TPipeSubscribeResp struct {
	Status  *common.TSStatus `thrift:"status,1,required" db:"status" json:"status"`
	Version int8             `thrift:"version,2,required" db:"version" json:"version"`
	Type    int16            `thrift:"type,3,required" db:"type" json:"type"`
	Body    [][]byte         `thrift:"body,4" db:"body" json:"body,omitempty"`
}

Attributes:

  • Status
  • Version
  • Type
  • Body
var IClientRPCServicePipeSubscribeResult_Success_DEFAULT *TPipeSubscribeResp

func NewTPipeSubscribeResp 

func NewTPipeSubscribeResp() *TPipeSubscribeResp

func (*TPipeSubscribeResp) Equals 

func (p *TPipeSubscribeResp) Equals(other *TPipeSubscribeResp) bool

func (*TPipeSubscribeResp) GetBody 

func (p *TPipeSubscribeResp) GetBody() [][]byte

func (*TPipeSubscribeResp) GetStatus 

func (p *TPipeSubscribeResp) GetStatus() *common.TSStatus

func (*TPipeSubscribeResp) GetType 

func (p *TPipeSubscribeResp) GetType() int16

func (*TPipeSubscribeResp) GetVersion 

func (p *TPipeSubscribeResp) GetVersion() int8

func (*TPipeSubscribeResp) IsSetBody 

func (p *TPipeSubscribeResp) IsSetBody() bool

func (*TPipeSubscribeResp) IsSetStatus 

func (p *TPipeSubscribeResp) IsSetStatus() bool

func (*TPipeSubscribeResp) Read 

func (p *TPipeSubscribeResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeSubscribeResp) ReadField1 

func (p *TPipeSubscribeResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeSubscribeResp) ReadField2 

func (p *TPipeSubscribeResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeSubscribeResp) ReadField3 

func (p *TPipeSubscribeResp) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeSubscribeResp) ReadField4 

func (p *TPipeSubscribeResp) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeSubscribeResp) String 

func (p *TPipeSubscribeResp) String() string

func (*TPipeSubscribeResp) Write 

func (p *TPipeSubscribeResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TPipeTransferReq 

type TPipeTransferReq struct {
	Version int8   `thrift:"version,1,required" db:"version" json:"version"`
	Type    int16  `thrift:"type,2,required" db:"type" json:"type"`
	Body    []byte `thrift:"body,3,required" db:"body" json:"body"`
}

Attributes:

  • Version
  • Type
  • Body
var IClientRPCServicePipeTransferArgs_Req_DEFAULT *TPipeTransferReq

func NewTPipeTransferReq 

func NewTPipeTransferReq() *TPipeTransferReq

func (*TPipeTransferReq) Equals 

func (p *TPipeTransferReq) Equals(other *TPipeTransferReq) bool

func (*TPipeTransferReq) GetBody 

func (p *TPipeTransferReq) GetBody() []byte

func (*TPipeTransferReq) GetType 

func (p *TPipeTransferReq) GetType() int16

func (*TPipeTransferReq) GetVersion 

func (p *TPipeTransferReq) GetVersion() int8

func (*TPipeTransferReq) Read 

func (p *TPipeTransferReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeTransferReq) ReadField1 

func (p *TPipeTransferReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeTransferReq) ReadField2 

func (p *TPipeTransferReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeTransferReq) ReadField3 

func (p *TPipeTransferReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeTransferReq) String 

func (p *TPipeTransferReq) String() string

func (*TPipeTransferReq) Write 

func (p *TPipeTransferReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TPipeTransferResp 

type TPipeTransferResp struct {
	Status *common.TSStatus `thrift:"status,1,required" db:"status" json:"status"`
	Body   []byte           `thrift:"body,2" db:"body" json:"body,omitempty"`
}

Attributes:

  • Status
  • Body
var IClientRPCServicePipeTransferResult_Success_DEFAULT *TPipeTransferResp

func NewTPipeTransferResp 

func NewTPipeTransferResp() *TPipeTransferResp

func (*TPipeTransferResp) Equals 

func (p *TPipeTransferResp) Equals(other *TPipeTransferResp) bool

func (*TPipeTransferResp) GetBody 

func (p *TPipeTransferResp) GetBody() []byte

func (*TPipeTransferResp) GetStatus 

func (p *TPipeTransferResp) GetStatus() *common.TSStatus

func (*TPipeTransferResp) IsSetBody 

func (p *TPipeTransferResp) IsSetBody() bool

func (*TPipeTransferResp) IsSetStatus 

func (p *TPipeTransferResp) IsSetStatus() bool

func (*TPipeTransferResp) Read 

func (p *TPipeTransferResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeTransferResp) ReadField1 

func (p *TPipeTransferResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeTransferResp) ReadField2 

func (p *TPipeTransferResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TPipeTransferResp) String 

func (p *TPipeTransferResp) String() string

func (*TPipeTransferResp) Write 

func (p *TPipeTransferResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSAggregationQueryReq 

type TSAggregationQueryReq struct {
	SessionId      int64                     `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	StatementId    int64                     `thrift:"statementId,2,required" db:"statementId" json:"statementId"`
	Paths          []string                  `thrift:"paths,3,required" db:"paths" json:"paths"`
	Aggregations   []common.TAggregationType `thrift:"aggregations,4,required" db:"aggregations" json:"aggregations"`
	StartTime      *int64                    `thrift:"startTime,5" db:"startTime" json:"startTime,omitempty"`
	EndTime        *int64                    `thrift:"endTime,6" db:"endTime" json:"endTime,omitempty"`
	Interval       *int64                    `thrift:"interval,7" db:"interval" json:"interval,omitempty"`
	SlidingStep    *int64                    `thrift:"slidingStep,8" db:"slidingStep" json:"slidingStep,omitempty"`
	FetchSize      *int32                    `thrift:"fetchSize,9" db:"fetchSize" json:"fetchSize,omitempty"`
	Timeout        *int64                    `thrift:"timeout,10" db:"timeout" json:"timeout,omitempty"`
	LegalPathNodes *bool                     `thrift:"legalPathNodes,11" db:"legalPathNodes" json:"legalPathNodes,omitempty"`
}

Attributes:

  • SessionId
  • StatementId
  • Paths
  • Aggregations
  • StartTime
  • EndTime
  • Interval
  • SlidingStep
  • FetchSize
  • Timeout
  • LegalPathNodes
var IClientRPCServiceExecuteAggregationQueryArgs_Req_DEFAULT *TSAggregationQueryReq
var IClientRPCServiceExecuteAggregationQueryV2Args_Req_DEFAULT *TSAggregationQueryReq

func NewTSAggregationQueryReq 

func NewTSAggregationQueryReq() *TSAggregationQueryReq

func (*TSAggregationQueryReq) Equals 

func (p *TSAggregationQueryReq) Equals(other *TSAggregationQueryReq) bool

func (*TSAggregationQueryReq) GetAggregations 

func (p *TSAggregationQueryReq) GetAggregations() []common.TAggregationType

func (*TSAggregationQueryReq) GetEndTime 

func (p *TSAggregationQueryReq) GetEndTime() int64

func (*TSAggregationQueryReq) GetFetchSize 

func (p *TSAggregationQueryReq) GetFetchSize() int32

func (*TSAggregationQueryReq) GetInterval 

func (p *TSAggregationQueryReq) GetInterval() int64

func (*TSAggregationQueryReq) GetLegalPathNodes 

func (p *TSAggregationQueryReq) GetLegalPathNodes() bool

func (*TSAggregationQueryReq) GetPaths 

func (p *TSAggregationQueryReq) GetPaths() []string

func (*TSAggregationQueryReq) GetSessionId 

func (p *TSAggregationQueryReq) GetSessionId() int64

func (*TSAggregationQueryReq) GetSlidingStep 

func (p *TSAggregationQueryReq) GetSlidingStep() int64

func (*TSAggregationQueryReq) GetStartTime 

func (p *TSAggregationQueryReq) GetStartTime() int64

func (*TSAggregationQueryReq) GetStatementId 

func (p *TSAggregationQueryReq) GetStatementId() int64

func (*TSAggregationQueryReq) GetTimeout 

func (p *TSAggregationQueryReq) GetTimeout() int64

func (*TSAggregationQueryReq) IsSetEndTime 

func (p *TSAggregationQueryReq) IsSetEndTime() bool

func (*TSAggregationQueryReq) IsSetFetchSize 

func (p *TSAggregationQueryReq) IsSetFetchSize() bool

func (*TSAggregationQueryReq) IsSetInterval 

func (p *TSAggregationQueryReq) IsSetInterval() bool

func (*TSAggregationQueryReq) IsSetLegalPathNodes 

func (p *TSAggregationQueryReq) IsSetLegalPathNodes() bool

func (*TSAggregationQueryReq) IsSetSlidingStep 

func (p *TSAggregationQueryReq) IsSetSlidingStep() bool

func (*TSAggregationQueryReq) IsSetStartTime 

func (p *TSAggregationQueryReq) IsSetStartTime() bool

func (*TSAggregationQueryReq) IsSetTimeout 

func (p *TSAggregationQueryReq) IsSetTimeout() bool

func (*TSAggregationQueryReq) Read 

func (p *TSAggregationQueryReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField1 

func (p *TSAggregationQueryReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField10 

func (p *TSAggregationQueryReq) ReadField10(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField11 

func (p *TSAggregationQueryReq) ReadField11(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField2 

func (p *TSAggregationQueryReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField3 

func (p *TSAggregationQueryReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField4 

func (p *TSAggregationQueryReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField5 

func (p *TSAggregationQueryReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField6 

func (p *TSAggregationQueryReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField7 

func (p *TSAggregationQueryReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField8 

func (p *TSAggregationQueryReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) ReadField9 

func (p *TSAggregationQueryReq) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAggregationQueryReq) String 

func (p *TSAggregationQueryReq) String() string

func (*TSAggregationQueryReq) Write 

func (p *TSAggregationQueryReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSAppendSchemaTemplateReq 

type TSAppendSchemaTemplateReq struct {
	SessionId    int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Name         string   `thrift:"name,2,required" db:"name" json:"name"`
	IsAligned    bool     `thrift:"isAligned,3,required" db:"isAligned" json:"isAligned"`
	Measurements []string `thrift:"measurements,4,required" db:"measurements" json:"measurements"`
	DataTypes    []int32  `thrift:"dataTypes,5,required" db:"dataTypes" json:"dataTypes"`
	Encodings    []int32  `thrift:"encodings,6,required" db:"encodings" json:"encodings"`
	Compressors  []int32  `thrift:"compressors,7,required" db:"compressors" json:"compressors"`
}

Attributes:

  • SessionId
  • Name
  • IsAligned
  • Measurements
  • DataTypes
  • Encodings
  • Compressors
var IClientRPCServiceAppendSchemaTemplateArgs_Req_DEFAULT *TSAppendSchemaTemplateReq

func NewTSAppendSchemaTemplateReq 

func NewTSAppendSchemaTemplateReq() *TSAppendSchemaTemplateReq

func (*TSAppendSchemaTemplateReq) Equals 

func (p *TSAppendSchemaTemplateReq) Equals(other *TSAppendSchemaTemplateReq) bool

func (*TSAppendSchemaTemplateReq) GetCompressors 

func (p *TSAppendSchemaTemplateReq) GetCompressors() []int32

func (*TSAppendSchemaTemplateReq) GetDataTypes 

func (p *TSAppendSchemaTemplateReq) GetDataTypes() []int32

func (*TSAppendSchemaTemplateReq) GetEncodings 

func (p *TSAppendSchemaTemplateReq) GetEncodings() []int32

func (*TSAppendSchemaTemplateReq) GetIsAligned 

func (p *TSAppendSchemaTemplateReq) GetIsAligned() bool

func (*TSAppendSchemaTemplateReq) GetMeasurements 

func (p *TSAppendSchemaTemplateReq) GetMeasurements() []string

func (*TSAppendSchemaTemplateReq) GetName 

func (p *TSAppendSchemaTemplateReq) GetName() string

func (*TSAppendSchemaTemplateReq) GetSessionId 

func (p *TSAppendSchemaTemplateReq) GetSessionId() int64

func (*TSAppendSchemaTemplateReq) Read 

func (p *TSAppendSchemaTemplateReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAppendSchemaTemplateReq) ReadField1 

func (p *TSAppendSchemaTemplateReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAppendSchemaTemplateReq) ReadField2 

func (p *TSAppendSchemaTemplateReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAppendSchemaTemplateReq) ReadField3 

func (p *TSAppendSchemaTemplateReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAppendSchemaTemplateReq) ReadField4 

func (p *TSAppendSchemaTemplateReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAppendSchemaTemplateReq) ReadField5 

func (p *TSAppendSchemaTemplateReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAppendSchemaTemplateReq) ReadField6 

func (p *TSAppendSchemaTemplateReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAppendSchemaTemplateReq) ReadField7 

func (p *TSAppendSchemaTemplateReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSAppendSchemaTemplateReq) String 

func (p *TSAppendSchemaTemplateReq) String() string

func (*TSAppendSchemaTemplateReq) Write 

func (p *TSAppendSchemaTemplateReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSBackupConfigurationResp 

type TSBackupConfigurationResp struct {
	Status              *common.TSStatus `thrift:"status,1,required" db:"status" json:"status"`
	EnableOperationSync *bool            `thrift:"enableOperationSync,2" db:"enableOperationSync" json:"enableOperationSync,omitempty"`
	SecondaryAddress    *string          `thrift:"secondaryAddress,3" db:"secondaryAddress" json:"secondaryAddress,omitempty"`
	SecondaryPort       *int32           `thrift:"secondaryPort,4" db:"secondaryPort" json:"secondaryPort,omitempty"`
}

Attributes:

  • Status
  • EnableOperationSync
  • SecondaryAddress
  • SecondaryPort
var IClientRPCServiceGetBackupConfigurationResult_Success_DEFAULT *TSBackupConfigurationResp

func NewTSBackupConfigurationResp 

func NewTSBackupConfigurationResp() *TSBackupConfigurationResp

func (*TSBackupConfigurationResp) Equals 

func (p *TSBackupConfigurationResp) Equals(other *TSBackupConfigurationResp) bool

func (*TSBackupConfigurationResp) GetEnableOperationSync 

func (p *TSBackupConfigurationResp) GetEnableOperationSync() bool

func (*TSBackupConfigurationResp) GetSecondaryAddress 

func (p *TSBackupConfigurationResp) GetSecondaryAddress() string

func (*TSBackupConfigurationResp) GetSecondaryPort 

func (p *TSBackupConfigurationResp) GetSecondaryPort() int32

func (*TSBackupConfigurationResp) GetStatus 

func (p *TSBackupConfigurationResp) GetStatus() *common.TSStatus

func (*TSBackupConfigurationResp) IsSetEnableOperationSync 

func (p *TSBackupConfigurationResp) IsSetEnableOperationSync() bool

func (*TSBackupConfigurationResp) IsSetSecondaryAddress 

func (p *TSBackupConfigurationResp) IsSetSecondaryAddress() bool

func (*TSBackupConfigurationResp) IsSetSecondaryPort 

func (p *TSBackupConfigurationResp) IsSetSecondaryPort() bool

func (*TSBackupConfigurationResp) IsSetStatus 

func (p *TSBackupConfigurationResp) IsSetStatus() bool

func (*TSBackupConfigurationResp) Read 

func (p *TSBackupConfigurationResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSBackupConfigurationResp) ReadField1 

func (p *TSBackupConfigurationResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSBackupConfigurationResp) ReadField2 

func (p *TSBackupConfigurationResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSBackupConfigurationResp) ReadField3 

func (p *TSBackupConfigurationResp) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSBackupConfigurationResp) ReadField4 

func (p *TSBackupConfigurationResp) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSBackupConfigurationResp) String 

func (p *TSBackupConfigurationResp) String() string

func (*TSBackupConfigurationResp) Write 

func (p *TSBackupConfigurationResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSCancelOperationReq 

type TSCancelOperationReq struct {
	SessionId int64 `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	QueryId   int64 `thrift:"queryId,2,required" db:"queryId" json:"queryId"`
}

Attributes:

  • SessionId
  • QueryId
var IClientRPCServiceCancelOperationArgs_Req_DEFAULT *TSCancelOperationReq

func NewTSCancelOperationReq 

func NewTSCancelOperationReq() *TSCancelOperationReq

func (*TSCancelOperationReq) Equals 

func (p *TSCancelOperationReq) Equals(other *TSCancelOperationReq) bool

func (*TSCancelOperationReq) GetQueryId 

func (p *TSCancelOperationReq) GetQueryId() int64

func (*TSCancelOperationReq) GetSessionId 

func (p *TSCancelOperationReq) GetSessionId() int64

func (*TSCancelOperationReq) Read 

func (p *TSCancelOperationReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCancelOperationReq) ReadField1 

func (p *TSCancelOperationReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCancelOperationReq) ReadField2 

func (p *TSCancelOperationReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCancelOperationReq) String 

func (p *TSCancelOperationReq) String() string

func (*TSCancelOperationReq) Write 

func (p *TSCancelOperationReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSCloseOperationReq 

type TSCloseOperationReq struct {
	SessionId   int64  `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	QueryId     *int64 `thrift:"queryId,2" db:"queryId" json:"queryId,omitempty"`
	StatementId *int64 `thrift:"statementId,3" db:"statementId" json:"statementId,omitempty"`
}

Attributes:

  • SessionId
  • QueryId
  • StatementId
var IClientRPCServiceCloseOperationArgs_Req_DEFAULT *TSCloseOperationReq

func NewTSCloseOperationReq 

func NewTSCloseOperationReq() *TSCloseOperationReq

func (*TSCloseOperationReq) Equals 

func (p *TSCloseOperationReq) Equals(other *TSCloseOperationReq) bool

func (*TSCloseOperationReq) GetQueryId 

func (p *TSCloseOperationReq) GetQueryId() int64

func (*TSCloseOperationReq) GetSessionId 

func (p *TSCloseOperationReq) GetSessionId() int64

func (*TSCloseOperationReq) GetStatementId 

func (p *TSCloseOperationReq) GetStatementId() int64

func (*TSCloseOperationReq) IsSetQueryId 

func (p *TSCloseOperationReq) IsSetQueryId() bool

func (*TSCloseOperationReq) IsSetStatementId 

func (p *TSCloseOperationReq) IsSetStatementId() bool

func (*TSCloseOperationReq) Read 

func (p *TSCloseOperationReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCloseOperationReq) ReadField1 

func (p *TSCloseOperationReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCloseOperationReq) ReadField2 

func (p *TSCloseOperationReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCloseOperationReq) ReadField3 

func (p *TSCloseOperationReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCloseOperationReq) String 

func (p *TSCloseOperationReq) String() string

func (*TSCloseOperationReq) Write 

func (p *TSCloseOperationReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSCloseSessionReq 

type TSCloseSessionReq struct {
	SessionId int64 `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
}

Attributes:

  • SessionId
var IClientRPCServiceCloseSessionArgs_Req_DEFAULT *TSCloseSessionReq

func NewTSCloseSessionReq 

func NewTSCloseSessionReq() *TSCloseSessionReq

func (*TSCloseSessionReq) Equals 

func (p *TSCloseSessionReq) Equals(other *TSCloseSessionReq) bool

func (*TSCloseSessionReq) GetSessionId 

func (p *TSCloseSessionReq) GetSessionId() int64

func (*TSCloseSessionReq) Read 

func (p *TSCloseSessionReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCloseSessionReq) ReadField1 

func (p *TSCloseSessionReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCloseSessionReq) String 

func (p *TSCloseSessionReq) String() string

func (*TSCloseSessionReq) Write 

func (p *TSCloseSessionReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSConnectionInfo 

type TSConnectionInfo struct {
	UserName     string           `thrift:"userName,1,required" db:"userName" json:"userName"`
	LogInTime    int64            `thrift:"logInTime,2,required" db:"logInTime" json:"logInTime"`
	ConnectionId string           `thrift:"connectionId,3,required" db:"connectionId" json:"connectionId"`
	Type         TSConnectionType `thrift:"type,4,required" db:"type" json:"type"`
}

Attributes:

  • UserName
  • LogInTime
  • ConnectionId
  • Type

func NewTSConnectionInfo 

func NewTSConnectionInfo() *TSConnectionInfo

func (*TSConnectionInfo) Equals 

func (p *TSConnectionInfo) Equals(other *TSConnectionInfo) bool

func (*TSConnectionInfo) GetConnectionId 

func (p *TSConnectionInfo) GetConnectionId() string

func (*TSConnectionInfo) GetLogInTime 

func (p *TSConnectionInfo) GetLogInTime() int64

func (*TSConnectionInfo) GetType 

func (p *TSConnectionInfo) GetType() TSConnectionType

func (*TSConnectionInfo) GetUserName 

func (p *TSConnectionInfo) GetUserName() string

func (*TSConnectionInfo) Read 

func (p *TSConnectionInfo) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSConnectionInfo) ReadField1 

func (p *TSConnectionInfo) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSConnectionInfo) ReadField2 

func (p *TSConnectionInfo) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSConnectionInfo) ReadField3 

func (p *TSConnectionInfo) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSConnectionInfo) ReadField4 

func (p *TSConnectionInfo) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSConnectionInfo) String 

func (p *TSConnectionInfo) String() string

func (*TSConnectionInfo) Write 

func (p *TSConnectionInfo) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSConnectionInfoResp 

type TSConnectionInfoResp struct {
	ConnectionInfoList []*TSConnectionInfo `thrift:"connectionInfoList,1,required" db:"connectionInfoList" json:"connectionInfoList"`
}

Attributes:

  • ConnectionInfoList
var IClientRPCServiceFetchAllConnectionsInfoResult_Success_DEFAULT *TSConnectionInfoResp

func NewTSConnectionInfoResp 

func NewTSConnectionInfoResp() *TSConnectionInfoResp

func (*TSConnectionInfoResp) Equals 

func (p *TSConnectionInfoResp) Equals(other *TSConnectionInfoResp) bool

func (*TSConnectionInfoResp) GetConnectionInfoList 

func (p *TSConnectionInfoResp) GetConnectionInfoList() []*TSConnectionInfo

func (*TSConnectionInfoResp) Read 

func (p *TSConnectionInfoResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSConnectionInfoResp) ReadField1 

func (p *TSConnectionInfoResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSConnectionInfoResp) String 

func (p *TSConnectionInfoResp) String() string

func (*TSConnectionInfoResp) Write 

func (p *TSConnectionInfoResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSConnectionType 

type TSConnectionType int64
const (
	TSConnectionType_THRIFT_BASED TSConnectionType = 0
	TSConnectionType_MQTT_BASED   TSConnectionType = 1
	TSConnectionType_INTERNAL     TSConnectionType = 2
	TSConnectionType_REST_BASED   TSConnectionType = 3
)

func TSConnectionTypeFromString 

func TSConnectionTypeFromString(s string) (TSConnectionType, error)

func TSConnectionTypePtr 

func TSConnectionTypePtr(v TSConnectionType) *TSConnectionType

func (TSConnectionType) MarshalText 

func (p TSConnectionType) MarshalText() ([]byte, error)

func (*TSConnectionType) Scan 

func (p *TSConnectionType) Scan(value interface{}) error

func (TSConnectionType) String 

func (p TSConnectionType) String() string

func (*TSConnectionType) UnmarshalText 

func (p *TSConnectionType) UnmarshalText(text []byte) error

func (*TSConnectionType) Value 

func (p *TSConnectionType) Value() (driver.Value, error)

type TSCreateAlignedTimeseriesReq 

type TSCreateAlignedTimeseriesReq struct {
	SessionId        int64               `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPath       string              `thrift:"prefixPath,2,required" db:"prefixPath" json:"prefixPath"`
	Measurements     []string            `thrift:"measurements,3,required" db:"measurements" json:"measurements"`
	DataTypes        []int32             `thrift:"dataTypes,4,required" db:"dataTypes" json:"dataTypes"`
	Encodings        []int32             `thrift:"encodings,5,required" db:"encodings" json:"encodings"`
	Compressors      []int32             `thrift:"compressors,6,required" db:"compressors" json:"compressors"`
	MeasurementAlias []string            `thrift:"measurementAlias,7" db:"measurementAlias" json:"measurementAlias,omitempty"`
	TagsList         []map[string]string `thrift:"tagsList,8" db:"tagsList" json:"tagsList,omitempty"`
	AttributesList   []map[string]string `thrift:"attributesList,9" db:"attributesList" json:"attributesList,omitempty"`
}

Attributes:

  • SessionId
  • PrefixPath
  • Measurements
  • DataTypes
  • Encodings
  • Compressors
  • MeasurementAlias
  • TagsList
  • AttributesList
var IClientRPCServiceCreateAlignedTimeseriesArgs_Req_DEFAULT *TSCreateAlignedTimeseriesReq

func NewTSCreateAlignedTimeseriesReq 

func NewTSCreateAlignedTimeseriesReq() *TSCreateAlignedTimeseriesReq

func (*TSCreateAlignedTimeseriesReq) Equals 

func (p *TSCreateAlignedTimeseriesReq) Equals(other *TSCreateAlignedTimeseriesReq) bool

func (*TSCreateAlignedTimeseriesReq) GetAttributesList 

func (p *TSCreateAlignedTimeseriesReq) GetAttributesList() []map[string]string

func (*TSCreateAlignedTimeseriesReq) GetCompressors 

func (p *TSCreateAlignedTimeseriesReq) GetCompressors() []int32

func (*TSCreateAlignedTimeseriesReq) GetDataTypes 

func (p *TSCreateAlignedTimeseriesReq) GetDataTypes() []int32

func (*TSCreateAlignedTimeseriesReq) GetEncodings 

func (p *TSCreateAlignedTimeseriesReq) GetEncodings() []int32

func (*TSCreateAlignedTimeseriesReq) GetMeasurementAlias 

func (p *TSCreateAlignedTimeseriesReq) GetMeasurementAlias() []string

func (*TSCreateAlignedTimeseriesReq) GetMeasurements 

func (p *TSCreateAlignedTimeseriesReq) GetMeasurements() []string

func (*TSCreateAlignedTimeseriesReq) GetPrefixPath 

func (p *TSCreateAlignedTimeseriesReq) GetPrefixPath() string

func (*TSCreateAlignedTimeseriesReq) GetSessionId 

func (p *TSCreateAlignedTimeseriesReq) GetSessionId() int64

func (*TSCreateAlignedTimeseriesReq) GetTagsList 

func (p *TSCreateAlignedTimeseriesReq) GetTagsList() []map[string]string

func (*TSCreateAlignedTimeseriesReq) IsSetAttributesList 

func (p *TSCreateAlignedTimeseriesReq) IsSetAttributesList() bool

func (*TSCreateAlignedTimeseriesReq) IsSetMeasurementAlias 

func (p *TSCreateAlignedTimeseriesReq) IsSetMeasurementAlias() bool

func (*TSCreateAlignedTimeseriesReq) IsSetTagsList 

func (p *TSCreateAlignedTimeseriesReq) IsSetTagsList() bool

func (*TSCreateAlignedTimeseriesReq) Read 

func (p *TSCreateAlignedTimeseriesReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) ReadField1 

func (p *TSCreateAlignedTimeseriesReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) ReadField2 

func (p *TSCreateAlignedTimeseriesReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) ReadField3 

func (p *TSCreateAlignedTimeseriesReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) ReadField4 

func (p *TSCreateAlignedTimeseriesReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) ReadField5 

func (p *TSCreateAlignedTimeseriesReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) ReadField6 

func (p *TSCreateAlignedTimeseriesReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) ReadField7 

func (p *TSCreateAlignedTimeseriesReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) ReadField8 

func (p *TSCreateAlignedTimeseriesReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) ReadField9 

func (p *TSCreateAlignedTimeseriesReq) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateAlignedTimeseriesReq) String 

func (p *TSCreateAlignedTimeseriesReq) String() string

func (*TSCreateAlignedTimeseriesReq) Write 

func (p *TSCreateAlignedTimeseriesReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSCreateMultiTimeseriesReq 

type TSCreateMultiTimeseriesReq struct {
	SessionId            int64               `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Paths                []string            `thrift:"paths,2,required" db:"paths" json:"paths"`
	DataTypes            []int32             `thrift:"dataTypes,3,required" db:"dataTypes" json:"dataTypes"`
	Encodings            []int32             `thrift:"encodings,4,required" db:"encodings" json:"encodings"`
	Compressors          []int32             `thrift:"compressors,5,required" db:"compressors" json:"compressors"`
	PropsList            []map[string]string `thrift:"propsList,6" db:"propsList" json:"propsList,omitempty"`
	TagsList             []map[string]string `thrift:"tagsList,7" db:"tagsList" json:"tagsList,omitempty"`
	AttributesList       []map[string]string `thrift:"attributesList,8" db:"attributesList" json:"attributesList,omitempty"`
	MeasurementAliasList []string            `thrift:"measurementAliasList,9" db:"measurementAliasList" json:"measurementAliasList,omitempty"`
}

Attributes:

  • SessionId
  • Paths
  • DataTypes
  • Encodings
  • Compressors
  • PropsList
  • TagsList
  • AttributesList
  • MeasurementAliasList
var IClientRPCServiceCreateMultiTimeseriesArgs_Req_DEFAULT *TSCreateMultiTimeseriesReq

func NewTSCreateMultiTimeseriesReq 

func NewTSCreateMultiTimeseriesReq() *TSCreateMultiTimeseriesReq

func (*TSCreateMultiTimeseriesReq) Equals 

func (p *TSCreateMultiTimeseriesReq) Equals(other *TSCreateMultiTimeseriesReq) bool

func (*TSCreateMultiTimeseriesReq) GetAttributesList 

func (p *TSCreateMultiTimeseriesReq) GetAttributesList() []map[string]string

func (*TSCreateMultiTimeseriesReq) GetCompressors 

func (p *TSCreateMultiTimeseriesReq) GetCompressors() []int32

func (*TSCreateMultiTimeseriesReq) GetDataTypes 

func (p *TSCreateMultiTimeseriesReq) GetDataTypes() []int32

func (*TSCreateMultiTimeseriesReq) GetEncodings 

func (p *TSCreateMultiTimeseriesReq) GetEncodings() []int32

func (*TSCreateMultiTimeseriesReq) GetMeasurementAliasList 

func (p *TSCreateMultiTimeseriesReq) GetMeasurementAliasList() []string

func (*TSCreateMultiTimeseriesReq) GetPaths 

func (p *TSCreateMultiTimeseriesReq) GetPaths() []string

func (*TSCreateMultiTimeseriesReq) GetPropsList 

func (p *TSCreateMultiTimeseriesReq) GetPropsList() []map[string]string

func (*TSCreateMultiTimeseriesReq) GetSessionId 

func (p *TSCreateMultiTimeseriesReq) GetSessionId() int64

func (*TSCreateMultiTimeseriesReq) GetTagsList 

func (p *TSCreateMultiTimeseriesReq) GetTagsList() []map[string]string

func (*TSCreateMultiTimeseriesReq) IsSetAttributesList 

func (p *TSCreateMultiTimeseriesReq) IsSetAttributesList() bool

func (*TSCreateMultiTimeseriesReq) IsSetMeasurementAliasList 

func (p *TSCreateMultiTimeseriesReq) IsSetMeasurementAliasList() bool

func (*TSCreateMultiTimeseriesReq) IsSetPropsList 

func (p *TSCreateMultiTimeseriesReq) IsSetPropsList() bool

func (*TSCreateMultiTimeseriesReq) IsSetTagsList 

func (p *TSCreateMultiTimeseriesReq) IsSetTagsList() bool

func (*TSCreateMultiTimeseriesReq) Read 

func (p *TSCreateMultiTimeseriesReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) ReadField1 

func (p *TSCreateMultiTimeseriesReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) ReadField2 

func (p *TSCreateMultiTimeseriesReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) ReadField3 

func (p *TSCreateMultiTimeseriesReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) ReadField4 

func (p *TSCreateMultiTimeseriesReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) ReadField5 

func (p *TSCreateMultiTimeseriesReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) ReadField6 

func (p *TSCreateMultiTimeseriesReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) ReadField7 

func (p *TSCreateMultiTimeseriesReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) ReadField8 

func (p *TSCreateMultiTimeseriesReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) ReadField9 

func (p *TSCreateMultiTimeseriesReq) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateMultiTimeseriesReq) String 

func (p *TSCreateMultiTimeseriesReq) String() string

func (*TSCreateMultiTimeseriesReq) Write 

func (p *TSCreateMultiTimeseriesReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSCreateSchemaTemplateReq 

type TSCreateSchemaTemplateReq struct {
	SessionId          int64  `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Name               string `thrift:"name,2,required" db:"name" json:"name"`
	SerializedTemplate []byte `thrift:"serializedTemplate,3,required" db:"serializedTemplate" json:"serializedTemplate"`
}

Attributes:

  • SessionId
  • Name
  • SerializedTemplate
var IClientRPCServiceCreateSchemaTemplateArgs_Req_DEFAULT *TSCreateSchemaTemplateReq

func NewTSCreateSchemaTemplateReq 

func NewTSCreateSchemaTemplateReq() *TSCreateSchemaTemplateReq

func (*TSCreateSchemaTemplateReq) Equals 

func (p *TSCreateSchemaTemplateReq) Equals(other *TSCreateSchemaTemplateReq) bool

func (*TSCreateSchemaTemplateReq) GetName 

func (p *TSCreateSchemaTemplateReq) GetName() string

func (*TSCreateSchemaTemplateReq) GetSerializedTemplate 

func (p *TSCreateSchemaTemplateReq) GetSerializedTemplate() []byte

func (*TSCreateSchemaTemplateReq) GetSessionId 

func (p *TSCreateSchemaTemplateReq) GetSessionId() int64

func (*TSCreateSchemaTemplateReq) Read 

func (p *TSCreateSchemaTemplateReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateSchemaTemplateReq) ReadField1 

func (p *TSCreateSchemaTemplateReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateSchemaTemplateReq) ReadField2 

func (p *TSCreateSchemaTemplateReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateSchemaTemplateReq) ReadField3 

func (p *TSCreateSchemaTemplateReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateSchemaTemplateReq) String 

func (p *TSCreateSchemaTemplateReq) String() string

func (*TSCreateSchemaTemplateReq) Write 

func (p *TSCreateSchemaTemplateReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSCreateTimeseriesReq 

type TSCreateTimeseriesReq struct {
	SessionId        int64             `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Path             string            `thrift:"path,2,required" db:"path" json:"path"`
	DataType         int32             `thrift:"dataType,3,required" db:"dataType" json:"dataType"`
	Encoding         int32             `thrift:"encoding,4,required" db:"encoding" json:"encoding"`
	Compressor       int32             `thrift:"compressor,5,required" db:"compressor" json:"compressor"`
	Props            map[string]string `thrift:"props,6" db:"props" json:"props,omitempty"`
	Tags             map[string]string `thrift:"tags,7" db:"tags" json:"tags,omitempty"`
	Attributes       map[string]string `thrift:"attributes,8" db:"attributes" json:"attributes,omitempty"`
	MeasurementAlias *string           `thrift:"measurementAlias,9" db:"measurementAlias" json:"measurementAlias,omitempty"`
}

Attributes:

  • SessionId
  • Path
  • DataType
  • Encoding
  • Compressor
  • Props
  • Tags
  • Attributes
  • MeasurementAlias
var IClientRPCServiceCreateTimeseriesArgs_Req_DEFAULT *TSCreateTimeseriesReq

func NewTSCreateTimeseriesReq 

func NewTSCreateTimeseriesReq() *TSCreateTimeseriesReq

func (*TSCreateTimeseriesReq) Equals 

func (p *TSCreateTimeseriesReq) Equals(other *TSCreateTimeseriesReq) bool

func (*TSCreateTimeseriesReq) GetAttributes 

func (p *TSCreateTimeseriesReq) GetAttributes() map[string]string

func (*TSCreateTimeseriesReq) GetCompressor 

func (p *TSCreateTimeseriesReq) GetCompressor() int32

func (*TSCreateTimeseriesReq) GetDataType 

func (p *TSCreateTimeseriesReq) GetDataType() int32

func (*TSCreateTimeseriesReq) GetEncoding 

func (p *TSCreateTimeseriesReq) GetEncoding() int32

func (*TSCreateTimeseriesReq) GetMeasurementAlias 

func (p *TSCreateTimeseriesReq) GetMeasurementAlias() string

func (*TSCreateTimeseriesReq) GetPath 

func (p *TSCreateTimeseriesReq) GetPath() string

func (*TSCreateTimeseriesReq) GetProps 

func (p *TSCreateTimeseriesReq) GetProps() map[string]string

func (*TSCreateTimeseriesReq) GetSessionId 

func (p *TSCreateTimeseriesReq) GetSessionId() int64

func (*TSCreateTimeseriesReq) GetTags 

func (p *TSCreateTimeseriesReq) GetTags() map[string]string

func (*TSCreateTimeseriesReq) IsSetAttributes 

func (p *TSCreateTimeseriesReq) IsSetAttributes() bool

func (*TSCreateTimeseriesReq) IsSetMeasurementAlias 

func (p *TSCreateTimeseriesReq) IsSetMeasurementAlias() bool

func (*TSCreateTimeseriesReq) IsSetProps 

func (p *TSCreateTimeseriesReq) IsSetProps() bool

func (*TSCreateTimeseriesReq) IsSetTags 

func (p *TSCreateTimeseriesReq) IsSetTags() bool

func (*TSCreateTimeseriesReq) Read 

func (p *TSCreateTimeseriesReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) ReadField1 

func (p *TSCreateTimeseriesReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) ReadField2 

func (p *TSCreateTimeseriesReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) ReadField3 

func (p *TSCreateTimeseriesReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) ReadField4 

func (p *TSCreateTimeseriesReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) ReadField5 

func (p *TSCreateTimeseriesReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) ReadField6 

func (p *TSCreateTimeseriesReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) ReadField7 

func (p *TSCreateTimeseriesReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) ReadField8 

func (p *TSCreateTimeseriesReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) ReadField9 

func (p *TSCreateTimeseriesReq) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSCreateTimeseriesReq) String 

func (p *TSCreateTimeseriesReq) String() string

func (*TSCreateTimeseriesReq) Write 

func (p *TSCreateTimeseriesReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSDeleteDataReq 

type TSDeleteDataReq struct {
	SessionId int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Paths     []string `thrift:"paths,2,required" db:"paths" json:"paths"`
	StartTime int64    `thrift:"startTime,3,required" db:"startTime" json:"startTime"`
	EndTime   int64    `thrift:"endTime,4,required" db:"endTime" json:"endTime"`
}

Attributes:

  • SessionId
  • Paths
  • StartTime
  • EndTime
var IClientRPCServiceDeleteDataArgs_Req_DEFAULT *TSDeleteDataReq

func NewTSDeleteDataReq 

func NewTSDeleteDataReq() *TSDeleteDataReq

func (*TSDeleteDataReq) Equals 

func (p *TSDeleteDataReq) Equals(other *TSDeleteDataReq) bool

func (*TSDeleteDataReq) GetEndTime 

func (p *TSDeleteDataReq) GetEndTime() int64

func (*TSDeleteDataReq) GetPaths 

func (p *TSDeleteDataReq) GetPaths() []string

func (*TSDeleteDataReq) GetSessionId 

func (p *TSDeleteDataReq) GetSessionId() int64

func (*TSDeleteDataReq) GetStartTime 

func (p *TSDeleteDataReq) GetStartTime() int64

func (*TSDeleteDataReq) Read 

func (p *TSDeleteDataReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSDeleteDataReq) ReadField1 

func (p *TSDeleteDataReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSDeleteDataReq) ReadField2 

func (p *TSDeleteDataReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSDeleteDataReq) ReadField3 

func (p *TSDeleteDataReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSDeleteDataReq) ReadField4 

func (p *TSDeleteDataReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSDeleteDataReq) String 

func (p *TSDeleteDataReq) String() string

func (*TSDeleteDataReq) Write 

func (p *TSDeleteDataReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSDropSchemaTemplateReq 

type TSDropSchemaTemplateReq struct {
	SessionId    int64  `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	TemplateName string `thrift:"templateName,2,required" db:"templateName" json:"templateName"`
}

Attributes:

  • SessionId
  • TemplateName
var IClientRPCServiceDropSchemaTemplateArgs_Req_DEFAULT *TSDropSchemaTemplateReq

func NewTSDropSchemaTemplateReq 

func NewTSDropSchemaTemplateReq() *TSDropSchemaTemplateReq

func (*TSDropSchemaTemplateReq) Equals 

func (p *TSDropSchemaTemplateReq) Equals(other *TSDropSchemaTemplateReq) bool

func (*TSDropSchemaTemplateReq) GetSessionId 

func (p *TSDropSchemaTemplateReq) GetSessionId() int64

func (*TSDropSchemaTemplateReq) GetTemplateName 

func (p *TSDropSchemaTemplateReq) GetTemplateName() string

func (*TSDropSchemaTemplateReq) Read 

func (p *TSDropSchemaTemplateReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSDropSchemaTemplateReq) ReadField1 

func (p *TSDropSchemaTemplateReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSDropSchemaTemplateReq) ReadField2 

func (p *TSDropSchemaTemplateReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSDropSchemaTemplateReq) String 

func (p *TSDropSchemaTemplateReq) String() string

func (*TSDropSchemaTemplateReq) Write 

func (p *TSDropSchemaTemplateReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSExecuteBatchStatementReq 

type TSExecuteBatchStatementReq struct {
	SessionId  int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Statements []string `thrift:"statements,2,required" db:"statements" json:"statements"`
}

Attributes:

  • SessionId
  • Statements
var IClientRPCServiceExecuteBatchStatementArgs_Req_DEFAULT *TSExecuteBatchStatementReq

func NewTSExecuteBatchStatementReq 

func NewTSExecuteBatchStatementReq() *TSExecuteBatchStatementReq

func (*TSExecuteBatchStatementReq) Equals 

func (p *TSExecuteBatchStatementReq) Equals(other *TSExecuteBatchStatementReq) bool

func (*TSExecuteBatchStatementReq) GetSessionId 

func (p *TSExecuteBatchStatementReq) GetSessionId() int64

func (*TSExecuteBatchStatementReq) GetStatements 

func (p *TSExecuteBatchStatementReq) GetStatements() []string

func (*TSExecuteBatchStatementReq) Read 

func (p *TSExecuteBatchStatementReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteBatchStatementReq) ReadField1 

func (p *TSExecuteBatchStatementReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteBatchStatementReq) ReadField2 

func (p *TSExecuteBatchStatementReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteBatchStatementReq) String 

func (p *TSExecuteBatchStatementReq) String() string

func (*TSExecuteBatchStatementReq) Write 

func (p *TSExecuteBatchStatementReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSExecuteStatementReq 

type TSExecuteStatementReq struct {
	SessionId           int64  `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Statement           string `thrift:"statement,2,required" db:"statement" json:"statement"`
	StatementId         int64  `thrift:"statementId,3,required" db:"statementId" json:"statementId"`
	FetchSize           *int32 `thrift:"fetchSize,4" db:"fetchSize" json:"fetchSize,omitempty"`
	Timeout             *int64 `thrift:"timeout,5" db:"timeout" json:"timeout,omitempty"`
	EnableRedirectQuery *bool  `thrift:"enableRedirectQuery,6" db:"enableRedirectQuery" json:"enableRedirectQuery,omitempty"`
	JdbcQuery           *bool  `thrift:"jdbcQuery,7" db:"jdbcQuery" json:"jdbcQuery,omitempty"`
}

Attributes:

  • SessionId
  • Statement
  • StatementId
  • FetchSize
  • Timeout
  • EnableRedirectQuery
  • JdbcQuery
var IClientRPCServiceExecuteQueryStatementArgs_Req_DEFAULT *TSExecuteStatementReq
var IClientRPCServiceExecuteQueryStatementV2Args_Req_DEFAULT *TSExecuteStatementReq
var IClientRPCServiceExecuteStatementArgs_Req_DEFAULT *TSExecuteStatementReq
var IClientRPCServiceExecuteStatementV2Args_Req_DEFAULT *TSExecuteStatementReq
var IClientRPCServiceExecuteUpdateStatementArgs_Req_DEFAULT *TSExecuteStatementReq
var IClientRPCServiceExecuteUpdateStatementV2Args_Req_DEFAULT *TSExecuteStatementReq

func NewTSExecuteStatementReq 

func NewTSExecuteStatementReq() *TSExecuteStatementReq

func (*TSExecuteStatementReq) Equals 

func (p *TSExecuteStatementReq) Equals(other *TSExecuteStatementReq) bool

func (*TSExecuteStatementReq) GetEnableRedirectQuery 

func (p *TSExecuteStatementReq) GetEnableRedirectQuery() bool

func (*TSExecuteStatementReq) GetFetchSize 

func (p *TSExecuteStatementReq) GetFetchSize() int32

func (*TSExecuteStatementReq) GetJdbcQuery 

func (p *TSExecuteStatementReq) GetJdbcQuery() bool

func (*TSExecuteStatementReq) GetSessionId 

func (p *TSExecuteStatementReq) GetSessionId() int64

func (*TSExecuteStatementReq) GetStatement 

func (p *TSExecuteStatementReq) GetStatement() string

func (*TSExecuteStatementReq) GetStatementId 

func (p *TSExecuteStatementReq) GetStatementId() int64

func (*TSExecuteStatementReq) GetTimeout 

func (p *TSExecuteStatementReq) GetTimeout() int64

func (*TSExecuteStatementReq) IsSetEnableRedirectQuery 

func (p *TSExecuteStatementReq) IsSetEnableRedirectQuery() bool

func (*TSExecuteStatementReq) IsSetFetchSize 

func (p *TSExecuteStatementReq) IsSetFetchSize() bool

func (*TSExecuteStatementReq) IsSetJdbcQuery 

func (p *TSExecuteStatementReq) IsSetJdbcQuery() bool

func (*TSExecuteStatementReq) IsSetTimeout 

func (p *TSExecuteStatementReq) IsSetTimeout() bool

func (*TSExecuteStatementReq) Read 

func (p *TSExecuteStatementReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementReq) ReadField1 

func (p *TSExecuteStatementReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementReq) ReadField2 

func (p *TSExecuteStatementReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementReq) ReadField3 

func (p *TSExecuteStatementReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementReq) ReadField4 

func (p *TSExecuteStatementReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementReq) ReadField5 

func (p *TSExecuteStatementReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementReq) ReadField6 

func (p *TSExecuteStatementReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementReq) ReadField7 

func (p *TSExecuteStatementReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementReq) String 

func (p *TSExecuteStatementReq) String() string

func (*TSExecuteStatementReq) Write 

func (p *TSExecuteStatementReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSExecuteStatementResp 

type TSExecuteStatementResp struct {
	Status                             *common.TSStatus        `thrift:"status,1,required" db:"status" json:"status"`
	QueryId                            *int64                  `thrift:"queryId,2" db:"queryId" json:"queryId,omitempty"`
	Columns                            []string                `thrift:"columns,3" db:"columns" json:"columns,omitempty"`
	OperationType                      *string                 `thrift:"operationType,4" db:"operationType" json:"operationType,omitempty"`
	IgnoreTimeStamp                    *bool                   `thrift:"ignoreTimeStamp,5" db:"ignoreTimeStamp" json:"ignoreTimeStamp,omitempty"`
	DataTypeList                       []string                `thrift:"dataTypeList,6" db:"dataTypeList" json:"dataTypeList,omitempty"`
	QueryDataSet                       *TSQueryDataSet         `thrift:"queryDataSet,7" db:"queryDataSet" json:"queryDataSet,omitempty"`
	NonAlignQueryDataSet               *TSQueryNonAlignDataSet `thrift:"nonAlignQueryDataSet,8" db:"nonAlignQueryDataSet" json:"nonAlignQueryDataSet,omitempty"`
	ColumnNameIndexMap                 map[string]int32        `thrift:"columnNameIndexMap,9" db:"columnNameIndexMap" json:"columnNameIndexMap,omitempty"`
	SgColumns                          []string                `thrift:"sgColumns,10" db:"sgColumns" json:"sgColumns,omitempty"`
	AliasColumns                       []int8                  `thrift:"aliasColumns,11" db:"aliasColumns" json:"aliasColumns,omitempty"`
	TracingInfo                        *TSTracingInfo          `thrift:"tracingInfo,12" db:"tracingInfo" json:"tracingInfo,omitempty"`
	QueryResult_                       [][]byte                `thrift:"queryResult,13" db:"queryResult" json:"queryResult,omitempty"`
	MoreData                           *bool                   `thrift:"moreData,14" db:"moreData" json:"moreData,omitempty"`
	Database                           *string                 `thrift:"database,15" db:"database" json:"database,omitempty"`
	TableModel                         *bool                   `thrift:"tableModel,16" db:"tableModel" json:"tableModel,omitempty"`
	ColumnIndex2TsBlockColumnIndexList []int32                 `` /* 138-byte string literal not displayed */
}

Attributes:

  • Status
  • QueryId
  • Columns
  • OperationType
  • IgnoreTimeStamp
  • DataTypeList
  • QueryDataSet
  • NonAlignQueryDataSet
  • ColumnNameIndexMap
  • SgColumns
  • AliasColumns
  • TracingInfo
  • QueryResult_
  • MoreData
  • Database
  • TableModel
  • ColumnIndex2TsBlockColumnIndexList
var IClientRPCServiceExecuteAggregationQueryResult_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteAggregationQueryV2Result_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Result_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathResult_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteGroupByQueryIntervalQueryResult_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteLastDataQueryResult_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteLastDataQueryV2Result_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteQueryStatementResult_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteQueryStatementV2Result_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteRawDataQueryResult_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteRawDataQueryV2Result_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteStatementResult_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteStatementV2Result_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteUpdateStatementResult_Success_DEFAULT *TSExecuteStatementResp
var IClientRPCServiceExecuteUpdateStatementV2Result_Success_DEFAULT *TSExecuteStatementResp

func NewTSExecuteStatementResp 

func NewTSExecuteStatementResp() *TSExecuteStatementResp

func (*TSExecuteStatementResp) Equals 

func (p *TSExecuteStatementResp) Equals(other *TSExecuteStatementResp) bool

func (*TSExecuteStatementResp) GetAliasColumns 

func (p *TSExecuteStatementResp) GetAliasColumns() []int8

func (*TSExecuteStatementResp) GetColumnIndex2TsBlockColumnIndexList 

func (p *TSExecuteStatementResp) GetColumnIndex2TsBlockColumnIndexList() []int32

func (*TSExecuteStatementResp) GetColumnNameIndexMap 

func (p *TSExecuteStatementResp) GetColumnNameIndexMap() map[string]int32

func (*TSExecuteStatementResp) GetColumns 

func (p *TSExecuteStatementResp) GetColumns() []string

func (*TSExecuteStatementResp) GetDataTypeList 

func (p *TSExecuteStatementResp) GetDataTypeList() []string

func (*TSExecuteStatementResp) GetDatabase 

func (p *TSExecuteStatementResp) GetDatabase() string

func (*TSExecuteStatementResp) GetIgnoreTimeStamp 

func (p *TSExecuteStatementResp) GetIgnoreTimeStamp() bool

func (*TSExecuteStatementResp) GetMoreData 

func (p *TSExecuteStatementResp) GetMoreData() bool

func (*TSExecuteStatementResp) GetNonAlignQueryDataSet 

func (p *TSExecuteStatementResp) GetNonAlignQueryDataSet() *TSQueryNonAlignDataSet

func (*TSExecuteStatementResp) GetOperationType 

func (p *TSExecuteStatementResp) GetOperationType() string

func (*TSExecuteStatementResp) GetQueryDataSet 

func (p *TSExecuteStatementResp) GetQueryDataSet() *TSQueryDataSet

func (*TSExecuteStatementResp) GetQueryId 

func (p *TSExecuteStatementResp) GetQueryId() int64

func (*TSExecuteStatementResp) GetQueryResult_ 

func (p *TSExecuteStatementResp) GetQueryResult_() [][]byte

func (*TSExecuteStatementResp) GetSgColumns 

func (p *TSExecuteStatementResp) GetSgColumns() []string

func (*TSExecuteStatementResp) GetStatus 

func (p *TSExecuteStatementResp) GetStatus() *common.TSStatus

func (*TSExecuteStatementResp) GetTableModel 

func (p *TSExecuteStatementResp) GetTableModel() bool

func (*TSExecuteStatementResp) GetTracingInfo 

func (p *TSExecuteStatementResp) GetTracingInfo() *TSTracingInfo

func (*TSExecuteStatementResp) IsSetAliasColumns 

func (p *TSExecuteStatementResp) IsSetAliasColumns() bool

func (*TSExecuteStatementResp) IsSetColumnIndex2TsBlockColumnIndexList 

func (p *TSExecuteStatementResp) IsSetColumnIndex2TsBlockColumnIndexList() bool

func (*TSExecuteStatementResp) IsSetColumnNameIndexMap 

func (p *TSExecuteStatementResp) IsSetColumnNameIndexMap() bool

func (*TSExecuteStatementResp) IsSetColumns 

func (p *TSExecuteStatementResp) IsSetColumns() bool

func (*TSExecuteStatementResp) IsSetDataTypeList 

func (p *TSExecuteStatementResp) IsSetDataTypeList() bool

func (*TSExecuteStatementResp) IsSetDatabase 

func (p *TSExecuteStatementResp) IsSetDatabase() bool

func (*TSExecuteStatementResp) IsSetIgnoreTimeStamp 

func (p *TSExecuteStatementResp) IsSetIgnoreTimeStamp() bool

func (*TSExecuteStatementResp) IsSetMoreData 

func (p *TSExecuteStatementResp) IsSetMoreData() bool

func (*TSExecuteStatementResp) IsSetNonAlignQueryDataSet 

func (p *TSExecuteStatementResp) IsSetNonAlignQueryDataSet() bool

func (*TSExecuteStatementResp) IsSetOperationType 

func (p *TSExecuteStatementResp) IsSetOperationType() bool

func (*TSExecuteStatementResp) IsSetQueryDataSet 

func (p *TSExecuteStatementResp) IsSetQueryDataSet() bool

func (*TSExecuteStatementResp) IsSetQueryId 

func (p *TSExecuteStatementResp) IsSetQueryId() bool

func (*TSExecuteStatementResp) IsSetQueryResult_ 

func (p *TSExecuteStatementResp) IsSetQueryResult_() bool

func (*TSExecuteStatementResp) IsSetSgColumns 

func (p *TSExecuteStatementResp) IsSetSgColumns() bool

func (*TSExecuteStatementResp) IsSetStatus 

func (p *TSExecuteStatementResp) IsSetStatus() bool

func (*TSExecuteStatementResp) IsSetTableModel 

func (p *TSExecuteStatementResp) IsSetTableModel() bool

func (*TSExecuteStatementResp) IsSetTracingInfo 

func (p *TSExecuteStatementResp) IsSetTracingInfo() bool

func (*TSExecuteStatementResp) Read 

func (p *TSExecuteStatementResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField1 

func (p *TSExecuteStatementResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField10 

func (p *TSExecuteStatementResp) ReadField10(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField11 

func (p *TSExecuteStatementResp) ReadField11(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField12 

func (p *TSExecuteStatementResp) ReadField12(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField13 

func (p *TSExecuteStatementResp) ReadField13(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField14 

func (p *TSExecuteStatementResp) ReadField14(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField15 

func (p *TSExecuteStatementResp) ReadField15(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField16 

func (p *TSExecuteStatementResp) ReadField16(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField17 

func (p *TSExecuteStatementResp) ReadField17(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField2 

func (p *TSExecuteStatementResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField3 

func (p *TSExecuteStatementResp) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField4 

func (p *TSExecuteStatementResp) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField5 

func (p *TSExecuteStatementResp) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField6 

func (p *TSExecuteStatementResp) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField7 

func (p *TSExecuteStatementResp) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField8 

func (p *TSExecuteStatementResp) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) ReadField9 

func (p *TSExecuteStatementResp) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSExecuteStatementResp) String 

func (p *TSExecuteStatementResp) String() string

func (*TSExecuteStatementResp) Write 

func (p *TSExecuteStatementResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSFastLastDataQueryForOneDeviceReq 

type TSFastLastDataQueryForOneDeviceReq struct {
	SessionId           int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Db                  string   `thrift:"db,2,required" db:"db" json:"db"`
	DeviceId            string   `thrift:"deviceId,3,required" db:"deviceId" json:"deviceId"`
	Sensors             []string `thrift:"sensors,4,required" db:"sensors" json:"sensors"`
	FetchSize           *int32   `thrift:"fetchSize,5" db:"fetchSize" json:"fetchSize,omitempty"`
	StatementId         int64    `thrift:"statementId,6,required" db:"statementId" json:"statementId"`
	EnableRedirectQuery *bool    `thrift:"enableRedirectQuery,7" db:"enableRedirectQuery" json:"enableRedirectQuery,omitempty"`
	JdbcQuery           *bool    `thrift:"jdbcQuery,8" db:"jdbcQuery" json:"jdbcQuery,omitempty"`
	Timeout             *int64   `thrift:"timeout,9" db:"timeout" json:"timeout,omitempty"`
	LegalPathNodes      *bool    `thrift:"legalPathNodes,10" db:"legalPathNodes" json:"legalPathNodes,omitempty"`
}

Attributes:

  • SessionId
  • Db
  • DeviceId
  • Sensors
  • FetchSize
  • StatementId
  • EnableRedirectQuery
  • JdbcQuery
  • Timeout
  • LegalPathNodes
var IClientRPCServiceExecuteFastLastDataQueryForOneDeviceV2Args_Req_DEFAULT *TSFastLastDataQueryForOneDeviceReq

func NewTSFastLastDataQueryForOneDeviceReq 

func NewTSFastLastDataQueryForOneDeviceReq() *TSFastLastDataQueryForOneDeviceReq

func (*TSFastLastDataQueryForOneDeviceReq) Equals 

func (p *TSFastLastDataQueryForOneDeviceReq) Equals(other *TSFastLastDataQueryForOneDeviceReq) bool

func (*TSFastLastDataQueryForOneDeviceReq) GetDb 

func (p *TSFastLastDataQueryForOneDeviceReq) GetDb() string

func (*TSFastLastDataQueryForOneDeviceReq) GetDeviceId 

func (p *TSFastLastDataQueryForOneDeviceReq) GetDeviceId() string

func (*TSFastLastDataQueryForOneDeviceReq) GetEnableRedirectQuery 

func (p *TSFastLastDataQueryForOneDeviceReq) GetEnableRedirectQuery() bool

func (*TSFastLastDataQueryForOneDeviceReq) GetFetchSize 

func (p *TSFastLastDataQueryForOneDeviceReq) GetFetchSize() int32

func (*TSFastLastDataQueryForOneDeviceReq) GetJdbcQuery 

func (p *TSFastLastDataQueryForOneDeviceReq) GetJdbcQuery() bool

func (*TSFastLastDataQueryForOneDeviceReq) GetLegalPathNodes 

func (p *TSFastLastDataQueryForOneDeviceReq) GetLegalPathNodes() bool

func (*TSFastLastDataQueryForOneDeviceReq) GetSensors 

func (p *TSFastLastDataQueryForOneDeviceReq) GetSensors() []string

func (*TSFastLastDataQueryForOneDeviceReq) GetSessionId 

func (p *TSFastLastDataQueryForOneDeviceReq) GetSessionId() int64

func (*TSFastLastDataQueryForOneDeviceReq) GetStatementId 

func (p *TSFastLastDataQueryForOneDeviceReq) GetStatementId() int64

func (*TSFastLastDataQueryForOneDeviceReq) GetTimeout 

func (p *TSFastLastDataQueryForOneDeviceReq) GetTimeout() int64

func (*TSFastLastDataQueryForOneDeviceReq) IsSetEnableRedirectQuery 

func (p *TSFastLastDataQueryForOneDeviceReq) IsSetEnableRedirectQuery() bool

func (*TSFastLastDataQueryForOneDeviceReq) IsSetFetchSize 

func (p *TSFastLastDataQueryForOneDeviceReq) IsSetFetchSize() bool

func (*TSFastLastDataQueryForOneDeviceReq) IsSetJdbcQuery 

func (p *TSFastLastDataQueryForOneDeviceReq) IsSetJdbcQuery() bool

func (*TSFastLastDataQueryForOneDeviceReq) IsSetLegalPathNodes 

func (p *TSFastLastDataQueryForOneDeviceReq) IsSetLegalPathNodes() bool

func (*TSFastLastDataQueryForOneDeviceReq) IsSetTimeout 

func (p *TSFastLastDataQueryForOneDeviceReq) IsSetTimeout() bool

func (*TSFastLastDataQueryForOneDeviceReq) Read 

func (p *TSFastLastDataQueryForOneDeviceReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField1 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField10 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField10(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField2 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField3 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField4 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField5 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField6 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField7 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField8 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) ReadField9 

func (p *TSFastLastDataQueryForOneDeviceReq) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOneDeviceReq) String 

func (p *TSFastLastDataQueryForOneDeviceReq) String() string

func (*TSFastLastDataQueryForOneDeviceReq) Write 

func (p *TSFastLastDataQueryForOneDeviceReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSFastLastDataQueryForOnePrefixPathReq 

type TSFastLastDataQueryForOnePrefixPathReq struct {
	SessionId           int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Prefixes            []string `thrift:"prefixes,2,required" db:"prefixes" json:"prefixes"`
	FetchSize           *int32   `thrift:"fetchSize,3" db:"fetchSize" json:"fetchSize,omitempty"`
	StatementId         int64    `thrift:"statementId,4,required" db:"statementId" json:"statementId"`
	EnableRedirectQuery *bool    `thrift:"enableRedirectQuery,5" db:"enableRedirectQuery" json:"enableRedirectQuery,omitempty"`
	JdbcQuery           *bool    `thrift:"jdbcQuery,6" db:"jdbcQuery" json:"jdbcQuery,omitempty"`
	Timeout             *int64   `thrift:"timeout,7" db:"timeout" json:"timeout,omitempty"`
}

Attributes:

  • SessionId
  • Prefixes
  • FetchSize
  • StatementId
  • EnableRedirectQuery
  • JdbcQuery
  • Timeout
var IClientRPCServiceExecuteFastLastDataQueryForOnePrefixPathArgs_Req_DEFAULT *TSFastLastDataQueryForOnePrefixPathReq

func NewTSFastLastDataQueryForOnePrefixPathReq 

func NewTSFastLastDataQueryForOnePrefixPathReq() *TSFastLastDataQueryForOnePrefixPathReq

func (*TSFastLastDataQueryForOnePrefixPathReq) Equals 

func (p *TSFastLastDataQueryForOnePrefixPathReq) Equals(other *TSFastLastDataQueryForOnePrefixPathReq) bool

func (*TSFastLastDataQueryForOnePrefixPathReq) GetEnableRedirectQuery 

func (p *TSFastLastDataQueryForOnePrefixPathReq) GetEnableRedirectQuery() bool

func (*TSFastLastDataQueryForOnePrefixPathReq) GetFetchSize 

func (p *TSFastLastDataQueryForOnePrefixPathReq) GetFetchSize() int32

func (*TSFastLastDataQueryForOnePrefixPathReq) GetJdbcQuery 

func (p *TSFastLastDataQueryForOnePrefixPathReq) GetJdbcQuery() bool

func (*TSFastLastDataQueryForOnePrefixPathReq) GetPrefixes 

func (p *TSFastLastDataQueryForOnePrefixPathReq) GetPrefixes() []string

func (*TSFastLastDataQueryForOnePrefixPathReq) GetSessionId 

func (p *TSFastLastDataQueryForOnePrefixPathReq) GetSessionId() int64

func (*TSFastLastDataQueryForOnePrefixPathReq) GetStatementId 

func (p *TSFastLastDataQueryForOnePrefixPathReq) GetStatementId() int64

func (*TSFastLastDataQueryForOnePrefixPathReq) GetTimeout 

func (p *TSFastLastDataQueryForOnePrefixPathReq) GetTimeout() int64

func (*TSFastLastDataQueryForOnePrefixPathReq) IsSetEnableRedirectQuery 

func (p *TSFastLastDataQueryForOnePrefixPathReq) IsSetEnableRedirectQuery() bool

func (*TSFastLastDataQueryForOnePrefixPathReq) IsSetFetchSize 

func (p *TSFastLastDataQueryForOnePrefixPathReq) IsSetFetchSize() bool

func (*TSFastLastDataQueryForOnePrefixPathReq) IsSetJdbcQuery 

func (p *TSFastLastDataQueryForOnePrefixPathReq) IsSetJdbcQuery() bool

func (*TSFastLastDataQueryForOnePrefixPathReq) IsSetTimeout 

func (p *TSFastLastDataQueryForOnePrefixPathReq) IsSetTimeout() bool

func (*TSFastLastDataQueryForOnePrefixPathReq) Read 

func (p *TSFastLastDataQueryForOnePrefixPathReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOnePrefixPathReq) ReadField1 

func (p *TSFastLastDataQueryForOnePrefixPathReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOnePrefixPathReq) ReadField2 

func (p *TSFastLastDataQueryForOnePrefixPathReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOnePrefixPathReq) ReadField3 

func (p *TSFastLastDataQueryForOnePrefixPathReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOnePrefixPathReq) ReadField4 

func (p *TSFastLastDataQueryForOnePrefixPathReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOnePrefixPathReq) ReadField5 

func (p *TSFastLastDataQueryForOnePrefixPathReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOnePrefixPathReq) ReadField6 

func (p *TSFastLastDataQueryForOnePrefixPathReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOnePrefixPathReq) ReadField7 

func (p *TSFastLastDataQueryForOnePrefixPathReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFastLastDataQueryForOnePrefixPathReq) String 

func (p *TSFastLastDataQueryForOnePrefixPathReq) String() string

func (*TSFastLastDataQueryForOnePrefixPathReq) Write 

func (p *TSFastLastDataQueryForOnePrefixPathReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSFetchMetadataReq 

type TSFetchMetadataReq struct {
	SessionId  int64   `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Type       string  `thrift:"type,2,required" db:"type" json:"type"`
	ColumnPath *string `thrift:"columnPath,3" db:"columnPath" json:"columnPath,omitempty"`
}

Attributes:

  • SessionId
  • Type
  • ColumnPath
var IClientRPCServiceFetchMetadataArgs_Req_DEFAULT *TSFetchMetadataReq

func NewTSFetchMetadataReq 

func NewTSFetchMetadataReq() *TSFetchMetadataReq

func (*TSFetchMetadataReq) Equals 

func (p *TSFetchMetadataReq) Equals(other *TSFetchMetadataReq) bool

func (*TSFetchMetadataReq) GetColumnPath 

func (p *TSFetchMetadataReq) GetColumnPath() string

func (*TSFetchMetadataReq) GetSessionId 

func (p *TSFetchMetadataReq) GetSessionId() int64

func (*TSFetchMetadataReq) GetType 

func (p *TSFetchMetadataReq) GetType() string

func (*TSFetchMetadataReq) IsSetColumnPath 

func (p *TSFetchMetadataReq) IsSetColumnPath() bool

func (*TSFetchMetadataReq) Read 

func (p *TSFetchMetadataReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchMetadataReq) ReadField1 

func (p *TSFetchMetadataReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchMetadataReq) ReadField2 

func (p *TSFetchMetadataReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchMetadataReq) ReadField3 

func (p *TSFetchMetadataReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchMetadataReq) String 

func (p *TSFetchMetadataReq) String() string

func (*TSFetchMetadataReq) Write 

func (p *TSFetchMetadataReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSFetchMetadataResp 

type TSFetchMetadataResp struct {
	Status         *common.TSStatus `thrift:"status,1,required" db:"status" json:"status"`
	MetadataInJson *string          `thrift:"metadataInJson,2" db:"metadataInJson" json:"metadataInJson,omitempty"`
	ColumnsList    []string         `thrift:"columnsList,3" db:"columnsList" json:"columnsList,omitempty"`
	DataType       *string          `thrift:"dataType,4" db:"dataType" json:"dataType,omitempty"`
}

Attributes:

  • Status
  • MetadataInJson
  • ColumnsList
  • DataType
var IClientRPCServiceFetchMetadataResult_Success_DEFAULT *TSFetchMetadataResp

func NewTSFetchMetadataResp 

func NewTSFetchMetadataResp() *TSFetchMetadataResp

func (*TSFetchMetadataResp) Equals 

func (p *TSFetchMetadataResp) Equals(other *TSFetchMetadataResp) bool

func (*TSFetchMetadataResp) GetColumnsList 

func (p *TSFetchMetadataResp) GetColumnsList() []string

func (*TSFetchMetadataResp) GetDataType 

func (p *TSFetchMetadataResp) GetDataType() string

func (*TSFetchMetadataResp) GetMetadataInJson 

func (p *TSFetchMetadataResp) GetMetadataInJson() string

func (*TSFetchMetadataResp) GetStatus 

func (p *TSFetchMetadataResp) GetStatus() *common.TSStatus

func (*TSFetchMetadataResp) IsSetColumnsList 

func (p *TSFetchMetadataResp) IsSetColumnsList() bool

func (*TSFetchMetadataResp) IsSetDataType 

func (p *TSFetchMetadataResp) IsSetDataType() bool

func (*TSFetchMetadataResp) IsSetMetadataInJson 

func (p *TSFetchMetadataResp) IsSetMetadataInJson() bool

func (*TSFetchMetadataResp) IsSetStatus 

func (p *TSFetchMetadataResp) IsSetStatus() bool

func (*TSFetchMetadataResp) Read 

func (p *TSFetchMetadataResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchMetadataResp) ReadField1 

func (p *TSFetchMetadataResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchMetadataResp) ReadField2 

func (p *TSFetchMetadataResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchMetadataResp) ReadField3 

func (p *TSFetchMetadataResp) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchMetadataResp) ReadField4 

func (p *TSFetchMetadataResp) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchMetadataResp) String 

func (p *TSFetchMetadataResp) String() string

func (*TSFetchMetadataResp) Write 

func (p *TSFetchMetadataResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSFetchResultsReq 

type TSFetchResultsReq struct {
	SessionId   int64  `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Statement   string `thrift:"statement,2,required" db:"statement" json:"statement"`
	FetchSize   int32  `thrift:"fetchSize,3,required" db:"fetchSize" json:"fetchSize"`
	QueryId     int64  `thrift:"queryId,4,required" db:"queryId" json:"queryId"`
	IsAlign     bool   `thrift:"isAlign,5,required" db:"isAlign" json:"isAlign"`
	Timeout     *int64 `thrift:"timeout,6" db:"timeout" json:"timeout,omitempty"`
	StatementId *int64 `thrift:"statementId,7" db:"statementId" json:"statementId,omitempty"`
}

Attributes:

  • SessionId
  • Statement
  • FetchSize
  • QueryId
  • IsAlign
  • Timeout
  • StatementId
var IClientRPCServiceFetchResultsArgs_Req_DEFAULT *TSFetchResultsReq
var IClientRPCServiceFetchResultsV2Args_Req_DEFAULT *TSFetchResultsReq

func NewTSFetchResultsReq 

func NewTSFetchResultsReq() *TSFetchResultsReq

func (*TSFetchResultsReq) Equals 

func (p *TSFetchResultsReq) Equals(other *TSFetchResultsReq) bool

func (*TSFetchResultsReq) GetFetchSize 

func (p *TSFetchResultsReq) GetFetchSize() int32

func (*TSFetchResultsReq) GetIsAlign 

func (p *TSFetchResultsReq) GetIsAlign() bool

func (*TSFetchResultsReq) GetQueryId 

func (p *TSFetchResultsReq) GetQueryId() int64

func (*TSFetchResultsReq) GetSessionId 

func (p *TSFetchResultsReq) GetSessionId() int64

func (*TSFetchResultsReq) GetStatement 

func (p *TSFetchResultsReq) GetStatement() string

func (*TSFetchResultsReq) GetStatementId 

func (p *TSFetchResultsReq) GetStatementId() int64

func (*TSFetchResultsReq) GetTimeout 

func (p *TSFetchResultsReq) GetTimeout() int64

func (*TSFetchResultsReq) IsSetStatementId 

func (p *TSFetchResultsReq) IsSetStatementId() bool

func (*TSFetchResultsReq) IsSetTimeout 

func (p *TSFetchResultsReq) IsSetTimeout() bool

func (*TSFetchResultsReq) Read 

func (p *TSFetchResultsReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsReq) ReadField1 

func (p *TSFetchResultsReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsReq) ReadField2 

func (p *TSFetchResultsReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsReq) ReadField3 

func (p *TSFetchResultsReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsReq) ReadField4 

func (p *TSFetchResultsReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsReq) ReadField5 

func (p *TSFetchResultsReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsReq) ReadField6 

func (p *TSFetchResultsReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsReq) ReadField7 

func (p *TSFetchResultsReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsReq) String 

func (p *TSFetchResultsReq) String() string

func (*TSFetchResultsReq) Write 

func (p *TSFetchResultsReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSFetchResultsResp 

type TSFetchResultsResp struct {
	Status               *common.TSStatus        `thrift:"status,1,required" db:"status" json:"status"`
	HasResultSet         bool                    `thrift:"hasResultSet,2,required" db:"hasResultSet" json:"hasResultSet"`
	IsAlign              bool                    `thrift:"isAlign,3,required" db:"isAlign" json:"isAlign"`
	QueryDataSet         *TSQueryDataSet         `thrift:"queryDataSet,4" db:"queryDataSet" json:"queryDataSet,omitempty"`
	NonAlignQueryDataSet *TSQueryNonAlignDataSet `thrift:"nonAlignQueryDataSet,5" db:"nonAlignQueryDataSet" json:"nonAlignQueryDataSet,omitempty"`
	QueryResult_         [][]byte                `thrift:"queryResult,6" db:"queryResult" json:"queryResult,omitempty"`
	MoreData             *bool                   `thrift:"moreData,7" db:"moreData" json:"moreData,omitempty"`
}

Attributes:

  • Status
  • HasResultSet
  • IsAlign
  • QueryDataSet
  • NonAlignQueryDataSet
  • QueryResult_
  • MoreData
var IClientRPCServiceFetchResultsResult_Success_DEFAULT *TSFetchResultsResp
var IClientRPCServiceFetchResultsV2Result_Success_DEFAULT *TSFetchResultsResp

func NewTSFetchResultsResp 

func NewTSFetchResultsResp() *TSFetchResultsResp

func (*TSFetchResultsResp) Equals 

func (p *TSFetchResultsResp) Equals(other *TSFetchResultsResp) bool

func (*TSFetchResultsResp) GetHasResultSet 

func (p *TSFetchResultsResp) GetHasResultSet() bool

func (*TSFetchResultsResp) GetIsAlign 

func (p *TSFetchResultsResp) GetIsAlign() bool

func (*TSFetchResultsResp) GetMoreData 

func (p *TSFetchResultsResp) GetMoreData() bool

func (*TSFetchResultsResp) GetNonAlignQueryDataSet 

func (p *TSFetchResultsResp) GetNonAlignQueryDataSet() *TSQueryNonAlignDataSet

func (*TSFetchResultsResp) GetQueryDataSet 

func (p *TSFetchResultsResp) GetQueryDataSet() *TSQueryDataSet

func (*TSFetchResultsResp) GetQueryResult_ 

func (p *TSFetchResultsResp) GetQueryResult_() [][]byte

func (*TSFetchResultsResp) GetStatus 

func (p *TSFetchResultsResp) GetStatus() *common.TSStatus

func (*TSFetchResultsResp) IsSetMoreData 

func (p *TSFetchResultsResp) IsSetMoreData() bool

func (*TSFetchResultsResp) IsSetNonAlignQueryDataSet 

func (p *TSFetchResultsResp) IsSetNonAlignQueryDataSet() bool

func (*TSFetchResultsResp) IsSetQueryDataSet 

func (p *TSFetchResultsResp) IsSetQueryDataSet() bool

func (*TSFetchResultsResp) IsSetQueryResult_ 

func (p *TSFetchResultsResp) IsSetQueryResult_() bool

func (*TSFetchResultsResp) IsSetStatus 

func (p *TSFetchResultsResp) IsSetStatus() bool

func (*TSFetchResultsResp) Read 

func (p *TSFetchResultsResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsResp) ReadField1 

func (p *TSFetchResultsResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsResp) ReadField2 

func (p *TSFetchResultsResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsResp) ReadField3 

func (p *TSFetchResultsResp) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsResp) ReadField4 

func (p *TSFetchResultsResp) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsResp) ReadField5 

func (p *TSFetchResultsResp) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsResp) ReadField6 

func (p *TSFetchResultsResp) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsResp) ReadField7 

func (p *TSFetchResultsResp) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSFetchResultsResp) String 

func (p *TSFetchResultsResp) String() string

func (*TSFetchResultsResp) Write 

func (p *TSFetchResultsResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSGetOperationStatusReq 

type TSGetOperationStatusReq struct {
	SessionId int64 `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	QueryId   int64 `thrift:"queryId,2,required" db:"queryId" json:"queryId"`
}

Attributes:

  • SessionId
  • QueryId

func NewTSGetOperationStatusReq 

func NewTSGetOperationStatusReq() *TSGetOperationStatusReq

func (*TSGetOperationStatusReq) Equals 

func (p *TSGetOperationStatusReq) Equals(other *TSGetOperationStatusReq) bool

func (*TSGetOperationStatusReq) GetQueryId 

func (p *TSGetOperationStatusReq) GetQueryId() int64

func (*TSGetOperationStatusReq) GetSessionId 

func (p *TSGetOperationStatusReq) GetSessionId() int64

func (*TSGetOperationStatusReq) Read 

func (p *TSGetOperationStatusReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGetOperationStatusReq) ReadField1 

func (p *TSGetOperationStatusReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGetOperationStatusReq) ReadField2 

func (p *TSGetOperationStatusReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGetOperationStatusReq) String 

func (p *TSGetOperationStatusReq) String() string

func (*TSGetOperationStatusReq) Write 

func (p *TSGetOperationStatusReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSGetTimeZoneResp 

type TSGetTimeZoneResp struct {
	Status   *common.TSStatus `thrift:"status,1,required" db:"status" json:"status"`
	TimeZone string           `thrift:"timeZone,2,required" db:"timeZone" json:"timeZone"`
}

Attributes:

  • Status
  • TimeZone
var IClientRPCServiceGetTimeZoneResult_Success_DEFAULT *TSGetTimeZoneResp

func NewTSGetTimeZoneResp 

func NewTSGetTimeZoneResp() *TSGetTimeZoneResp

func (*TSGetTimeZoneResp) Equals 

func (p *TSGetTimeZoneResp) Equals(other *TSGetTimeZoneResp) bool

func (*TSGetTimeZoneResp) GetStatus 

func (p *TSGetTimeZoneResp) GetStatus() *common.TSStatus

func (*TSGetTimeZoneResp) GetTimeZone 

func (p *TSGetTimeZoneResp) GetTimeZone() string

func (*TSGetTimeZoneResp) IsSetStatus 

func (p *TSGetTimeZoneResp) IsSetStatus() bool

func (*TSGetTimeZoneResp) Read 

func (p *TSGetTimeZoneResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGetTimeZoneResp) ReadField1 

func (p *TSGetTimeZoneResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGetTimeZoneResp) ReadField2 

func (p *TSGetTimeZoneResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGetTimeZoneResp) String 

func (p *TSGetTimeZoneResp) String() string

func (*TSGetTimeZoneResp) Write 

func (p *TSGetTimeZoneResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSGroupByQueryIntervalReq 

type TSGroupByQueryIntervalReq struct {
	SessionId       int64                   `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	StatementId     int64                   `thrift:"statementId,2,required" db:"statementId" json:"statementId"`
	Device          string                  `thrift:"device,3,required" db:"device" json:"device"`
	Measurement     string                  `thrift:"measurement,4,required" db:"measurement" json:"measurement"`
	DataType        int32                   `thrift:"dataType,5,required" db:"dataType" json:"dataType"`
	AggregationType common.TAggregationType `thrift:"aggregationType,6,required" db:"aggregationType" json:"aggregationType"`
	Database        *string                 `thrift:"database,7" db:"database" json:"database,omitempty"`
	StartTime       *int64                  `thrift:"startTime,8" db:"startTime" json:"startTime,omitempty"`
	EndTime         *int64                  `thrift:"endTime,9" db:"endTime" json:"endTime,omitempty"`
	Interval        *int64                  `thrift:"interval,10" db:"interval" json:"interval,omitempty"`
	FetchSize       *int32                  `thrift:"fetchSize,11" db:"fetchSize" json:"fetchSize,omitempty"`
	Timeout         *int64                  `thrift:"timeout,12" db:"timeout" json:"timeout,omitempty"`
	IsAligned       *bool                   `thrift:"isAligned,13" db:"isAligned" json:"isAligned,omitempty"`
}

Attributes:

  • SessionId
  • StatementId
  • Device
  • Measurement
  • DataType
  • AggregationType
  • Database
  • StartTime
  • EndTime
  • Interval
  • FetchSize
  • Timeout
  • IsAligned
var IClientRPCServiceExecuteGroupByQueryIntervalQueryArgs_Req_DEFAULT *TSGroupByQueryIntervalReq

func NewTSGroupByQueryIntervalReq 

func NewTSGroupByQueryIntervalReq() *TSGroupByQueryIntervalReq

func (*TSGroupByQueryIntervalReq) Equals 

func (p *TSGroupByQueryIntervalReq) Equals(other *TSGroupByQueryIntervalReq) bool

func (*TSGroupByQueryIntervalReq) GetAggregationType 

func (p *TSGroupByQueryIntervalReq) GetAggregationType() common.TAggregationType

func (*TSGroupByQueryIntervalReq) GetDataType 

func (p *TSGroupByQueryIntervalReq) GetDataType() int32

func (*TSGroupByQueryIntervalReq) GetDatabase 

func (p *TSGroupByQueryIntervalReq) GetDatabase() string

func (*TSGroupByQueryIntervalReq) GetDevice 

func (p *TSGroupByQueryIntervalReq) GetDevice() string

func (*TSGroupByQueryIntervalReq) GetEndTime 

func (p *TSGroupByQueryIntervalReq) GetEndTime() int64

func (*TSGroupByQueryIntervalReq) GetFetchSize 

func (p *TSGroupByQueryIntervalReq) GetFetchSize() int32

func (*TSGroupByQueryIntervalReq) GetInterval 

func (p *TSGroupByQueryIntervalReq) GetInterval() int64

func (*TSGroupByQueryIntervalReq) GetIsAligned 

func (p *TSGroupByQueryIntervalReq) GetIsAligned() bool

func (*TSGroupByQueryIntervalReq) GetMeasurement 

func (p *TSGroupByQueryIntervalReq) GetMeasurement() string

func (*TSGroupByQueryIntervalReq) GetSessionId 

func (p *TSGroupByQueryIntervalReq) GetSessionId() int64

func (*TSGroupByQueryIntervalReq) GetStartTime 

func (p *TSGroupByQueryIntervalReq) GetStartTime() int64

func (*TSGroupByQueryIntervalReq) GetStatementId 

func (p *TSGroupByQueryIntervalReq) GetStatementId() int64

func (*TSGroupByQueryIntervalReq) GetTimeout 

func (p *TSGroupByQueryIntervalReq) GetTimeout() int64

func (*TSGroupByQueryIntervalReq) IsSetDatabase 

func (p *TSGroupByQueryIntervalReq) IsSetDatabase() bool

func (*TSGroupByQueryIntervalReq) IsSetEndTime 

func (p *TSGroupByQueryIntervalReq) IsSetEndTime() bool

func (*TSGroupByQueryIntervalReq) IsSetFetchSize 

func (p *TSGroupByQueryIntervalReq) IsSetFetchSize() bool

func (*TSGroupByQueryIntervalReq) IsSetInterval 

func (p *TSGroupByQueryIntervalReq) IsSetInterval() bool

func (*TSGroupByQueryIntervalReq) IsSetIsAligned 

func (p *TSGroupByQueryIntervalReq) IsSetIsAligned() bool

func (*TSGroupByQueryIntervalReq) IsSetStartTime 

func (p *TSGroupByQueryIntervalReq) IsSetStartTime() bool

func (*TSGroupByQueryIntervalReq) IsSetTimeout 

func (p *TSGroupByQueryIntervalReq) IsSetTimeout() bool

func (*TSGroupByQueryIntervalReq) Read 

func (p *TSGroupByQueryIntervalReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField1 

func (p *TSGroupByQueryIntervalReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField10 

func (p *TSGroupByQueryIntervalReq) ReadField10(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField11 

func (p *TSGroupByQueryIntervalReq) ReadField11(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField12 

func (p *TSGroupByQueryIntervalReq) ReadField12(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField13 

func (p *TSGroupByQueryIntervalReq) ReadField13(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField2 

func (p *TSGroupByQueryIntervalReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField3 

func (p *TSGroupByQueryIntervalReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField4 

func (p *TSGroupByQueryIntervalReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField5 

func (p *TSGroupByQueryIntervalReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField6 

func (p *TSGroupByQueryIntervalReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField7 

func (p *TSGroupByQueryIntervalReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField8 

func (p *TSGroupByQueryIntervalReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) ReadField9 

func (p *TSGroupByQueryIntervalReq) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSGroupByQueryIntervalReq) String 

func (p *TSGroupByQueryIntervalReq) String() string

func (*TSGroupByQueryIntervalReq) Write 

func (p *TSGroupByQueryIntervalReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSInsertRecordReq 

type TSInsertRecordReq struct {
	SessionId         int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPath        string   `thrift:"prefixPath,2,required" db:"prefixPath" json:"prefixPath"`
	Measurements      []string `thrift:"measurements,3,required" db:"measurements" json:"measurements"`
	Values            []byte   `thrift:"values,4,required" db:"values" json:"values"`
	Timestamp         int64    `thrift:"timestamp,5,required" db:"timestamp" json:"timestamp"`
	IsAligned         *bool    `thrift:"isAligned,6" db:"isAligned" json:"isAligned,omitempty"`
	IsWriteToTable    *bool    `thrift:"isWriteToTable,7" db:"isWriteToTable" json:"isWriteToTable,omitempty"`
	ColumnCategoryies []int8   `thrift:"columnCategoryies,8" db:"columnCategoryies" json:"columnCategoryies,omitempty"`
}

Attributes:

  • SessionId
  • PrefixPath
  • Measurements
  • Values
  • Timestamp
  • IsAligned
  • IsWriteToTable
  • ColumnCategoryies
var IClientRPCServiceInsertRecordArgs_Req_DEFAULT *TSInsertRecordReq
var IClientRPCServiceTestInsertRecordArgs_Req_DEFAULT *TSInsertRecordReq

func NewTSInsertRecordReq 

func NewTSInsertRecordReq() *TSInsertRecordReq

func (*TSInsertRecordReq) Equals 

func (p *TSInsertRecordReq) Equals(other *TSInsertRecordReq) bool

func (*TSInsertRecordReq) GetColumnCategoryies 

func (p *TSInsertRecordReq) GetColumnCategoryies() []int8

func (*TSInsertRecordReq) GetIsAligned 

func (p *TSInsertRecordReq) GetIsAligned() bool

func (*TSInsertRecordReq) GetIsWriteToTable 

func (p *TSInsertRecordReq) GetIsWriteToTable() bool

func (*TSInsertRecordReq) GetMeasurements 

func (p *TSInsertRecordReq) GetMeasurements() []string

func (*TSInsertRecordReq) GetPrefixPath 

func (p *TSInsertRecordReq) GetPrefixPath() string

func (*TSInsertRecordReq) GetSessionId 

func (p *TSInsertRecordReq) GetSessionId() int64

func (*TSInsertRecordReq) GetTimestamp 

func (p *TSInsertRecordReq) GetTimestamp() int64

func (*TSInsertRecordReq) GetValues 

func (p *TSInsertRecordReq) GetValues() []byte

func (*TSInsertRecordReq) IsSetColumnCategoryies 

func (p *TSInsertRecordReq) IsSetColumnCategoryies() bool

func (*TSInsertRecordReq) IsSetIsAligned 

func (p *TSInsertRecordReq) IsSetIsAligned() bool

func (*TSInsertRecordReq) IsSetIsWriteToTable 

func (p *TSInsertRecordReq) IsSetIsWriteToTable() bool

func (*TSInsertRecordReq) Read 

func (p *TSInsertRecordReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordReq) ReadField1 

func (p *TSInsertRecordReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordReq) ReadField2 

func (p *TSInsertRecordReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordReq) ReadField3 

func (p *TSInsertRecordReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordReq) ReadField4 

func (p *TSInsertRecordReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordReq) ReadField5 

func (p *TSInsertRecordReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordReq) ReadField6 

func (p *TSInsertRecordReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordReq) ReadField7 

func (p *TSInsertRecordReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordReq) ReadField8 

func (p *TSInsertRecordReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordReq) String 

func (p *TSInsertRecordReq) String() string

func (*TSInsertRecordReq) Write 

func (p *TSInsertRecordReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSInsertRecordsOfOneDeviceReq 

type TSInsertRecordsOfOneDeviceReq struct {
	SessionId        int64      `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPath       string     `thrift:"prefixPath,2,required" db:"prefixPath" json:"prefixPath"`
	MeasurementsList [][]string `thrift:"measurementsList,3,required" db:"measurementsList" json:"measurementsList"`
	ValuesList       [][]byte   `thrift:"valuesList,4,required" db:"valuesList" json:"valuesList"`
	Timestamps       []int64    `thrift:"timestamps,5,required" db:"timestamps" json:"timestamps"`
	IsAligned        *bool      `thrift:"isAligned,6" db:"isAligned" json:"isAligned,omitempty"`
}

Attributes:

  • SessionId
  • PrefixPath
  • MeasurementsList
  • ValuesList
  • Timestamps
  • IsAligned
var IClientRPCServiceInsertRecordsOfOneDeviceArgs_Req_DEFAULT *TSInsertRecordsOfOneDeviceReq
var IClientRPCServiceTestInsertRecordsOfOneDeviceArgs_Req_DEFAULT *TSInsertRecordsOfOneDeviceReq

func NewTSInsertRecordsOfOneDeviceReq 

func NewTSInsertRecordsOfOneDeviceReq() *TSInsertRecordsOfOneDeviceReq

func (*TSInsertRecordsOfOneDeviceReq) Equals 

func (p *TSInsertRecordsOfOneDeviceReq) Equals(other *TSInsertRecordsOfOneDeviceReq) bool

func (*TSInsertRecordsOfOneDeviceReq) GetIsAligned 

func (p *TSInsertRecordsOfOneDeviceReq) GetIsAligned() bool

func (*TSInsertRecordsOfOneDeviceReq) GetMeasurementsList 

func (p *TSInsertRecordsOfOneDeviceReq) GetMeasurementsList() [][]string

func (*TSInsertRecordsOfOneDeviceReq) GetPrefixPath 

func (p *TSInsertRecordsOfOneDeviceReq) GetPrefixPath() string

func (*TSInsertRecordsOfOneDeviceReq) GetSessionId 

func (p *TSInsertRecordsOfOneDeviceReq) GetSessionId() int64

func (*TSInsertRecordsOfOneDeviceReq) GetTimestamps 

func (p *TSInsertRecordsOfOneDeviceReq) GetTimestamps() []int64

func (*TSInsertRecordsOfOneDeviceReq) GetValuesList 

func (p *TSInsertRecordsOfOneDeviceReq) GetValuesList() [][]byte

func (*TSInsertRecordsOfOneDeviceReq) IsSetIsAligned 

func (p *TSInsertRecordsOfOneDeviceReq) IsSetIsAligned() bool

func (*TSInsertRecordsOfOneDeviceReq) Read 

func (p *TSInsertRecordsOfOneDeviceReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsOfOneDeviceReq) ReadField1 

func (p *TSInsertRecordsOfOneDeviceReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsOfOneDeviceReq) ReadField2 

func (p *TSInsertRecordsOfOneDeviceReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsOfOneDeviceReq) ReadField3 

func (p *TSInsertRecordsOfOneDeviceReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsOfOneDeviceReq) ReadField4 

func (p *TSInsertRecordsOfOneDeviceReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsOfOneDeviceReq) ReadField5 

func (p *TSInsertRecordsOfOneDeviceReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsOfOneDeviceReq) ReadField6 

func (p *TSInsertRecordsOfOneDeviceReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsOfOneDeviceReq) String 

func (p *TSInsertRecordsOfOneDeviceReq) String() string

func (*TSInsertRecordsOfOneDeviceReq) Write 

func (p *TSInsertRecordsOfOneDeviceReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSInsertRecordsReq 

type TSInsertRecordsReq struct {
	SessionId        int64      `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPaths      []string   `thrift:"prefixPaths,2,required" db:"prefixPaths" json:"prefixPaths"`
	MeasurementsList [][]string `thrift:"measurementsList,3,required" db:"measurementsList" json:"measurementsList"`
	ValuesList       [][]byte   `thrift:"valuesList,4,required" db:"valuesList" json:"valuesList"`
	Timestamps       []int64    `thrift:"timestamps,5,required" db:"timestamps" json:"timestamps"`
	IsAligned        *bool      `thrift:"isAligned,6" db:"isAligned" json:"isAligned,omitempty"`
}

Attributes:

  • SessionId
  • PrefixPaths
  • MeasurementsList
  • ValuesList
  • Timestamps
  • IsAligned
var IClientRPCServiceInsertRecordsArgs_Req_DEFAULT *TSInsertRecordsReq
var IClientRPCServiceTestInsertRecordsArgs_Req_DEFAULT *TSInsertRecordsReq

func NewTSInsertRecordsReq 

func NewTSInsertRecordsReq() *TSInsertRecordsReq

func (*TSInsertRecordsReq) Equals 

func (p *TSInsertRecordsReq) Equals(other *TSInsertRecordsReq) bool

func (*TSInsertRecordsReq) GetIsAligned 

func (p *TSInsertRecordsReq) GetIsAligned() bool

func (*TSInsertRecordsReq) GetMeasurementsList 

func (p *TSInsertRecordsReq) GetMeasurementsList() [][]string

func (*TSInsertRecordsReq) GetPrefixPaths 

func (p *TSInsertRecordsReq) GetPrefixPaths() []string

func (*TSInsertRecordsReq) GetSessionId 

func (p *TSInsertRecordsReq) GetSessionId() int64

func (*TSInsertRecordsReq) GetTimestamps 

func (p *TSInsertRecordsReq) GetTimestamps() []int64

func (*TSInsertRecordsReq) GetValuesList 

func (p *TSInsertRecordsReq) GetValuesList() [][]byte

func (*TSInsertRecordsReq) IsSetIsAligned 

func (p *TSInsertRecordsReq) IsSetIsAligned() bool

func (*TSInsertRecordsReq) Read 

func (p *TSInsertRecordsReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsReq) ReadField1 

func (p *TSInsertRecordsReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsReq) ReadField2 

func (p *TSInsertRecordsReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsReq) ReadField3 

func (p *TSInsertRecordsReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsReq) ReadField4 

func (p *TSInsertRecordsReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsReq) ReadField5 

func (p *TSInsertRecordsReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsReq) ReadField6 

func (p *TSInsertRecordsReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertRecordsReq) String 

func (p *TSInsertRecordsReq) String() string

func (*TSInsertRecordsReq) Write 

func (p *TSInsertRecordsReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSInsertStringRecordReq 

type TSInsertStringRecordReq struct {
	SessionId    int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPath   string   `thrift:"prefixPath,2,required" db:"prefixPath" json:"prefixPath"`
	Measurements []string `thrift:"measurements,3,required" db:"measurements" json:"measurements"`
	Values       []string `thrift:"values,4,required" db:"values" json:"values"`
	Timestamp    int64    `thrift:"timestamp,5,required" db:"timestamp" json:"timestamp"`
	IsAligned    *bool    `thrift:"isAligned,6" db:"isAligned" json:"isAligned,omitempty"`
	Timeout      *int64   `thrift:"timeout,7" db:"timeout" json:"timeout,omitempty"`
}

Attributes:

  • SessionId
  • PrefixPath
  • Measurements
  • Values
  • Timestamp
  • IsAligned
  • Timeout
var IClientRPCServiceInsertStringRecordArgs_Req_DEFAULT *TSInsertStringRecordReq
var IClientRPCServiceTestInsertStringRecordArgs_Req_DEFAULT *TSInsertStringRecordReq

func NewTSInsertStringRecordReq 

func NewTSInsertStringRecordReq() *TSInsertStringRecordReq

func (*TSInsertStringRecordReq) Equals 

func (p *TSInsertStringRecordReq) Equals(other *TSInsertStringRecordReq) bool

func (*TSInsertStringRecordReq) GetIsAligned 

func (p *TSInsertStringRecordReq) GetIsAligned() bool

func (*TSInsertStringRecordReq) GetMeasurements 

func (p *TSInsertStringRecordReq) GetMeasurements() []string

func (*TSInsertStringRecordReq) GetPrefixPath 

func (p *TSInsertStringRecordReq) GetPrefixPath() string

func (*TSInsertStringRecordReq) GetSessionId 

func (p *TSInsertStringRecordReq) GetSessionId() int64

func (*TSInsertStringRecordReq) GetTimeout 

func (p *TSInsertStringRecordReq) GetTimeout() int64

func (*TSInsertStringRecordReq) GetTimestamp 

func (p *TSInsertStringRecordReq) GetTimestamp() int64

func (*TSInsertStringRecordReq) GetValues 

func (p *TSInsertStringRecordReq) GetValues() []string

func (*TSInsertStringRecordReq) IsSetIsAligned 

func (p *TSInsertStringRecordReq) IsSetIsAligned() bool

func (*TSInsertStringRecordReq) IsSetTimeout 

func (p *TSInsertStringRecordReq) IsSetTimeout() bool

func (*TSInsertStringRecordReq) Read 

func (p *TSInsertStringRecordReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordReq) ReadField1 

func (p *TSInsertStringRecordReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordReq) ReadField2 

func (p *TSInsertStringRecordReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordReq) ReadField3 

func (p *TSInsertStringRecordReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordReq) ReadField4 

func (p *TSInsertStringRecordReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordReq) ReadField5 

func (p *TSInsertStringRecordReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordReq) ReadField6 

func (p *TSInsertStringRecordReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordReq) ReadField7 

func (p *TSInsertStringRecordReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordReq) String 

func (p *TSInsertStringRecordReq) String() string

func (*TSInsertStringRecordReq) Write 

func (p *TSInsertStringRecordReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSInsertStringRecordsOfOneDeviceReq 

type TSInsertStringRecordsOfOneDeviceReq struct {
	SessionId        int64      `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPath       string     `thrift:"prefixPath,2,required" db:"prefixPath" json:"prefixPath"`
	MeasurementsList [][]string `thrift:"measurementsList,3,required" db:"measurementsList" json:"measurementsList"`
	ValuesList       [][]string `thrift:"valuesList,4,required" db:"valuesList" json:"valuesList"`
	Timestamps       []int64    `thrift:"timestamps,5,required" db:"timestamps" json:"timestamps"`
	IsAligned        *bool      `thrift:"isAligned,6" db:"isAligned" json:"isAligned,omitempty"`
}

Attributes:

  • SessionId
  • PrefixPath
  • MeasurementsList
  • ValuesList
  • Timestamps
  • IsAligned
var IClientRPCServiceInsertStringRecordsOfOneDeviceArgs_Req_DEFAULT *TSInsertStringRecordsOfOneDeviceReq

func NewTSInsertStringRecordsOfOneDeviceReq 

func NewTSInsertStringRecordsOfOneDeviceReq() *TSInsertStringRecordsOfOneDeviceReq

func (*TSInsertStringRecordsOfOneDeviceReq) Equals 

func (p *TSInsertStringRecordsOfOneDeviceReq) Equals(other *TSInsertStringRecordsOfOneDeviceReq) bool

func (*TSInsertStringRecordsOfOneDeviceReq) GetIsAligned 

func (p *TSInsertStringRecordsOfOneDeviceReq) GetIsAligned() bool

func (*TSInsertStringRecordsOfOneDeviceReq) GetMeasurementsList 

func (p *TSInsertStringRecordsOfOneDeviceReq) GetMeasurementsList() [][]string

func (*TSInsertStringRecordsOfOneDeviceReq) GetPrefixPath 

func (p *TSInsertStringRecordsOfOneDeviceReq) GetPrefixPath() string

func (*TSInsertStringRecordsOfOneDeviceReq) GetSessionId 

func (p *TSInsertStringRecordsOfOneDeviceReq) GetSessionId() int64

func (*TSInsertStringRecordsOfOneDeviceReq) GetTimestamps 

func (p *TSInsertStringRecordsOfOneDeviceReq) GetTimestamps() []int64

func (*TSInsertStringRecordsOfOneDeviceReq) GetValuesList 

func (p *TSInsertStringRecordsOfOneDeviceReq) GetValuesList() [][]string

func (*TSInsertStringRecordsOfOneDeviceReq) IsSetIsAligned 

func (p *TSInsertStringRecordsOfOneDeviceReq) IsSetIsAligned() bool

func (*TSInsertStringRecordsOfOneDeviceReq) Read 

func (p *TSInsertStringRecordsOfOneDeviceReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsOfOneDeviceReq) ReadField1 

func (p *TSInsertStringRecordsOfOneDeviceReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsOfOneDeviceReq) ReadField2 

func (p *TSInsertStringRecordsOfOneDeviceReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsOfOneDeviceReq) ReadField3 

func (p *TSInsertStringRecordsOfOneDeviceReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsOfOneDeviceReq) ReadField4 

func (p *TSInsertStringRecordsOfOneDeviceReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsOfOneDeviceReq) ReadField5 

func (p *TSInsertStringRecordsOfOneDeviceReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsOfOneDeviceReq) ReadField6 

func (p *TSInsertStringRecordsOfOneDeviceReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsOfOneDeviceReq) String 

func (p *TSInsertStringRecordsOfOneDeviceReq) String() string

func (*TSInsertStringRecordsOfOneDeviceReq) Write 

func (p *TSInsertStringRecordsOfOneDeviceReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSInsertStringRecordsReq 

type TSInsertStringRecordsReq struct {
	SessionId        int64      `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPaths      []string   `thrift:"prefixPaths,2,required" db:"prefixPaths" json:"prefixPaths"`
	MeasurementsList [][]string `thrift:"measurementsList,3,required" db:"measurementsList" json:"measurementsList"`
	ValuesList       [][]string `thrift:"valuesList,4,required" db:"valuesList" json:"valuesList"`
	Timestamps       []int64    `thrift:"timestamps,5,required" db:"timestamps" json:"timestamps"`
	IsAligned        *bool      `thrift:"isAligned,6" db:"isAligned" json:"isAligned,omitempty"`
}

Attributes:

  • SessionId
  • PrefixPaths
  • MeasurementsList
  • ValuesList
  • Timestamps
  • IsAligned
var IClientRPCServiceInsertStringRecordsArgs_Req_DEFAULT *TSInsertStringRecordsReq
var IClientRPCServiceTestInsertStringRecordsArgs_Req_DEFAULT *TSInsertStringRecordsReq

func NewTSInsertStringRecordsReq 

func NewTSInsertStringRecordsReq() *TSInsertStringRecordsReq

func (*TSInsertStringRecordsReq) Equals 

func (p *TSInsertStringRecordsReq) Equals(other *TSInsertStringRecordsReq) bool

func (*TSInsertStringRecordsReq) GetIsAligned 

func (p *TSInsertStringRecordsReq) GetIsAligned() bool

func (*TSInsertStringRecordsReq) GetMeasurementsList 

func (p *TSInsertStringRecordsReq) GetMeasurementsList() [][]string

func (*TSInsertStringRecordsReq) GetPrefixPaths 

func (p *TSInsertStringRecordsReq) GetPrefixPaths() []string

func (*TSInsertStringRecordsReq) GetSessionId 

func (p *TSInsertStringRecordsReq) GetSessionId() int64

func (*TSInsertStringRecordsReq) GetTimestamps 

func (p *TSInsertStringRecordsReq) GetTimestamps() []int64

func (*TSInsertStringRecordsReq) GetValuesList 

func (p *TSInsertStringRecordsReq) GetValuesList() [][]string

func (*TSInsertStringRecordsReq) IsSetIsAligned 

func (p *TSInsertStringRecordsReq) IsSetIsAligned() bool

func (*TSInsertStringRecordsReq) Read 

func (p *TSInsertStringRecordsReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsReq) ReadField1 

func (p *TSInsertStringRecordsReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsReq) ReadField2 

func (p *TSInsertStringRecordsReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsReq) ReadField3 

func (p *TSInsertStringRecordsReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsReq) ReadField4 

func (p *TSInsertStringRecordsReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsReq) ReadField5 

func (p *TSInsertStringRecordsReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsReq) ReadField6 

func (p *TSInsertStringRecordsReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertStringRecordsReq) String 

func (p *TSInsertStringRecordsReq) String() string

func (*TSInsertStringRecordsReq) Write 

func (p *TSInsertStringRecordsReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSInsertTabletReq 

type TSInsertTabletReq struct {
	SessionId        int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPath       string   `thrift:"prefixPath,2,required" db:"prefixPath" json:"prefixPath"`
	Measurements     []string `thrift:"measurements,3,required" db:"measurements" json:"measurements"`
	Values           []byte   `thrift:"values,4,required" db:"values" json:"values"`
	Timestamps       []byte   `thrift:"timestamps,5,required" db:"timestamps" json:"timestamps"`
	Types            []int32  `thrift:"types,6,required" db:"types" json:"types"`
	Size             int32    `thrift:"size,7,required" db:"size" json:"size"`
	IsAligned        *bool    `thrift:"isAligned,8" db:"isAligned" json:"isAligned,omitempty"`
	WriteToTable     *bool    `thrift:"writeToTable,9" db:"writeToTable" json:"writeToTable,omitempty"`
	ColumnCategories []int8   `thrift:"columnCategories,10" db:"columnCategories" json:"columnCategories,omitempty"`
}

Attributes:

  • SessionId
  • PrefixPath
  • Measurements
  • Values
  • Timestamps
  • Types
  • Size
  • IsAligned
  • WriteToTable
  • ColumnCategories
var IClientRPCServiceInsertTabletArgs_Req_DEFAULT *TSInsertTabletReq
var IClientRPCServiceTestInsertTabletArgs_Req_DEFAULT *TSInsertTabletReq

func NewTSInsertTabletReq 

func NewTSInsertTabletReq() *TSInsertTabletReq

func (*TSInsertTabletReq) Equals 

func (p *TSInsertTabletReq) Equals(other *TSInsertTabletReq) bool

func (*TSInsertTabletReq) GetColumnCategories 

func (p *TSInsertTabletReq) GetColumnCategories() []int8

func (*TSInsertTabletReq) GetIsAligned 

func (p *TSInsertTabletReq) GetIsAligned() bool

func (*TSInsertTabletReq) GetMeasurements 

func (p *TSInsertTabletReq) GetMeasurements() []string

func (*TSInsertTabletReq) GetPrefixPath 

func (p *TSInsertTabletReq) GetPrefixPath() string

func (*TSInsertTabletReq) GetSessionId 

func (p *TSInsertTabletReq) GetSessionId() int64

func (*TSInsertTabletReq) GetSize 

func (p *TSInsertTabletReq) GetSize() int32

func (*TSInsertTabletReq) GetTimestamps 

func (p *TSInsertTabletReq) GetTimestamps() []byte

func (*TSInsertTabletReq) GetTypes 

func (p *TSInsertTabletReq) GetTypes() []int32

func (*TSInsertTabletReq) GetValues 

func (p *TSInsertTabletReq) GetValues() []byte

func (*TSInsertTabletReq) GetWriteToTable 

func (p *TSInsertTabletReq) GetWriteToTable() bool

func (*TSInsertTabletReq) IsSetColumnCategories 

func (p *TSInsertTabletReq) IsSetColumnCategories() bool

func (*TSInsertTabletReq) IsSetIsAligned 

func (p *TSInsertTabletReq) IsSetIsAligned() bool

func (*TSInsertTabletReq) IsSetWriteToTable 

func (p *TSInsertTabletReq) IsSetWriteToTable() bool

func (*TSInsertTabletReq) Read 

func (p *TSInsertTabletReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField1 

func (p *TSInsertTabletReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField10 

func (p *TSInsertTabletReq) ReadField10(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField2 

func (p *TSInsertTabletReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField3 

func (p *TSInsertTabletReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField4 

func (p *TSInsertTabletReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField5 

func (p *TSInsertTabletReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField6 

func (p *TSInsertTabletReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField7 

func (p *TSInsertTabletReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField8 

func (p *TSInsertTabletReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) ReadField9 

func (p *TSInsertTabletReq) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletReq) String 

func (p *TSInsertTabletReq) String() string

func (*TSInsertTabletReq) Write 

func (p *TSInsertTabletReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSInsertTabletsReq 

type TSInsertTabletsReq struct {
	SessionId        int64      `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPaths      []string   `thrift:"prefixPaths,2,required" db:"prefixPaths" json:"prefixPaths"`
	MeasurementsList [][]string `thrift:"measurementsList,3,required" db:"measurementsList" json:"measurementsList"`
	ValuesList       [][]byte   `thrift:"valuesList,4,required" db:"valuesList" json:"valuesList"`
	TimestampsList   [][]byte   `thrift:"timestampsList,5,required" db:"timestampsList" json:"timestampsList"`
	TypesList        [][]int32  `thrift:"typesList,6,required" db:"typesList" json:"typesList"`
	SizeList         []int32    `thrift:"sizeList,7,required" db:"sizeList" json:"sizeList"`
	IsAligned        *bool      `thrift:"isAligned,8" db:"isAligned" json:"isAligned,omitempty"`
}

Attributes:

  • SessionId
  • PrefixPaths
  • MeasurementsList
  • ValuesList
  • TimestampsList
  • TypesList
  • SizeList
  • IsAligned
var IClientRPCServiceInsertTabletsArgs_Req_DEFAULT *TSInsertTabletsReq
var IClientRPCServiceTestInsertTabletsArgs_Req_DEFAULT *TSInsertTabletsReq

func NewTSInsertTabletsReq 

func NewTSInsertTabletsReq() *TSInsertTabletsReq

func (*TSInsertTabletsReq) Equals 

func (p *TSInsertTabletsReq) Equals(other *TSInsertTabletsReq) bool

func (*TSInsertTabletsReq) GetIsAligned 

func (p *TSInsertTabletsReq) GetIsAligned() bool

func (*TSInsertTabletsReq) GetMeasurementsList 

func (p *TSInsertTabletsReq) GetMeasurementsList() [][]string

func (*TSInsertTabletsReq) GetPrefixPaths 

func (p *TSInsertTabletsReq) GetPrefixPaths() []string

func (*TSInsertTabletsReq) GetSessionId 

func (p *TSInsertTabletsReq) GetSessionId() int64

func (*TSInsertTabletsReq) GetSizeList 

func (p *TSInsertTabletsReq) GetSizeList() []int32

func (*TSInsertTabletsReq) GetTimestampsList 

func (p *TSInsertTabletsReq) GetTimestampsList() [][]byte

func (*TSInsertTabletsReq) GetTypesList 

func (p *TSInsertTabletsReq) GetTypesList() [][]int32

func (*TSInsertTabletsReq) GetValuesList 

func (p *TSInsertTabletsReq) GetValuesList() [][]byte

func (*TSInsertTabletsReq) IsSetIsAligned 

func (p *TSInsertTabletsReq) IsSetIsAligned() bool

func (*TSInsertTabletsReq) Read 

func (p *TSInsertTabletsReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletsReq) ReadField1 

func (p *TSInsertTabletsReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletsReq) ReadField2 

func (p *TSInsertTabletsReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletsReq) ReadField3 

func (p *TSInsertTabletsReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletsReq) ReadField4 

func (p *TSInsertTabletsReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletsReq) ReadField5 

func (p *TSInsertTabletsReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletsReq) ReadField6 

func (p *TSInsertTabletsReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletsReq) ReadField7 

func (p *TSInsertTabletsReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletsReq) ReadField8 

func (p *TSInsertTabletsReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSInsertTabletsReq) String 

func (p *TSInsertTabletsReq) String() string

func (*TSInsertTabletsReq) Write 

func (p *TSInsertTabletsReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSLastDataQueryReq 

type TSLastDataQueryReq struct {
	SessionId           int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Paths               []string `thrift:"paths,2,required" db:"paths" json:"paths"`
	FetchSize           *int32   `thrift:"fetchSize,3" db:"fetchSize" json:"fetchSize,omitempty"`
	Time                int64    `thrift:"time,4,required" db:"time" json:"time"`
	StatementId         int64    `thrift:"statementId,5,required" db:"statementId" json:"statementId"`
	EnableRedirectQuery *bool    `thrift:"enableRedirectQuery,6" db:"enableRedirectQuery" json:"enableRedirectQuery,omitempty"`
	JdbcQuery           *bool    `thrift:"jdbcQuery,7" db:"jdbcQuery" json:"jdbcQuery,omitempty"`
	Timeout             *int64   `thrift:"timeout,8" db:"timeout" json:"timeout,omitempty"`
	LegalPathNodes      *bool    `thrift:"legalPathNodes,9" db:"legalPathNodes" json:"legalPathNodes,omitempty"`
}

Attributes:

  • SessionId
  • Paths
  • FetchSize
  • Time
  • StatementId
  • EnableRedirectQuery
  • JdbcQuery
  • Timeout
  • LegalPathNodes
var IClientRPCServiceExecuteLastDataQueryArgs_Req_DEFAULT *TSLastDataQueryReq
var IClientRPCServiceExecuteLastDataQueryV2Args_Req_DEFAULT *TSLastDataQueryReq

func NewTSLastDataQueryReq 

func NewTSLastDataQueryReq() *TSLastDataQueryReq

func (*TSLastDataQueryReq) Equals 

func (p *TSLastDataQueryReq) Equals(other *TSLastDataQueryReq) bool

func (*TSLastDataQueryReq) GetEnableRedirectQuery 

func (p *TSLastDataQueryReq) GetEnableRedirectQuery() bool

func (*TSLastDataQueryReq) GetFetchSize 

func (p *TSLastDataQueryReq) GetFetchSize() int32

func (*TSLastDataQueryReq) GetJdbcQuery 

func (p *TSLastDataQueryReq) GetJdbcQuery() bool

func (*TSLastDataQueryReq) GetLegalPathNodes 

func (p *TSLastDataQueryReq) GetLegalPathNodes() bool

func (*TSLastDataQueryReq) GetPaths 

func (p *TSLastDataQueryReq) GetPaths() []string

func (*TSLastDataQueryReq) GetSessionId 

func (p *TSLastDataQueryReq) GetSessionId() int64

func (*TSLastDataQueryReq) GetStatementId 

func (p *TSLastDataQueryReq) GetStatementId() int64

func (*TSLastDataQueryReq) GetTime 

func (p *TSLastDataQueryReq) GetTime() int64

func (*TSLastDataQueryReq) GetTimeout 

func (p *TSLastDataQueryReq) GetTimeout() int64

func (*TSLastDataQueryReq) IsSetEnableRedirectQuery 

func (p *TSLastDataQueryReq) IsSetEnableRedirectQuery() bool

func (*TSLastDataQueryReq) IsSetFetchSize 

func (p *TSLastDataQueryReq) IsSetFetchSize() bool

func (*TSLastDataQueryReq) IsSetJdbcQuery 

func (p *TSLastDataQueryReq) IsSetJdbcQuery() bool

func (*TSLastDataQueryReq) IsSetLegalPathNodes 

func (p *TSLastDataQueryReq) IsSetLegalPathNodes() bool

func (*TSLastDataQueryReq) IsSetTimeout 

func (p *TSLastDataQueryReq) IsSetTimeout() bool

func (*TSLastDataQueryReq) Read 

func (p *TSLastDataQueryReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) ReadField1 

func (p *TSLastDataQueryReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) ReadField2 

func (p *TSLastDataQueryReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) ReadField3 

func (p *TSLastDataQueryReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) ReadField4 

func (p *TSLastDataQueryReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) ReadField5 

func (p *TSLastDataQueryReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) ReadField6 

func (p *TSLastDataQueryReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) ReadField7 

func (p *TSLastDataQueryReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) ReadField8 

func (p *TSLastDataQueryReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) ReadField9 

func (p *TSLastDataQueryReq) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSLastDataQueryReq) String 

func (p *TSLastDataQueryReq) String() string

func (*TSLastDataQueryReq) Write 

func (p *TSLastDataQueryReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSOpenSessionReq 

type TSOpenSessionReq struct {
	ClientProtocol TSProtocolVersion `thrift:"client_protocol,1,required" db:"client_protocol" json:"client_protocol"`
	ZoneId         string            `thrift:"zoneId,2,required" db:"zoneId" json:"zoneId"`
	Username       string            `thrift:"username,3,required" db:"username" json:"username"`
	Password       *string           `thrift:"password,4" db:"password" json:"password,omitempty"`
	Configuration  map[string]string `thrift:"configuration,5" db:"configuration" json:"configuration,omitempty"`
}

Attributes:

  • ClientProtocol
  • ZoneId
  • Username
  • Password
  • Configuration
var IClientRPCServiceOpenSessionArgs_Req_DEFAULT *TSOpenSessionReq

func NewTSOpenSessionReq 

func NewTSOpenSessionReq() *TSOpenSessionReq

func (*TSOpenSessionReq) Equals 

func (p *TSOpenSessionReq) Equals(other *TSOpenSessionReq) bool

func (*TSOpenSessionReq) GetClientProtocol 

func (p *TSOpenSessionReq) GetClientProtocol() TSProtocolVersion

func (*TSOpenSessionReq) GetConfiguration 

func (p *TSOpenSessionReq) GetConfiguration() map[string]string

func (*TSOpenSessionReq) GetPassword 

func (p *TSOpenSessionReq) GetPassword() string

func (*TSOpenSessionReq) GetUsername 

func (p *TSOpenSessionReq) GetUsername() string

func (*TSOpenSessionReq) GetZoneId 

func (p *TSOpenSessionReq) GetZoneId() string

func (*TSOpenSessionReq) IsSetConfiguration 

func (p *TSOpenSessionReq) IsSetConfiguration() bool

func (*TSOpenSessionReq) IsSetPassword 

func (p *TSOpenSessionReq) IsSetPassword() bool

func (*TSOpenSessionReq) Read 

func (p *TSOpenSessionReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionReq) ReadField1 

func (p *TSOpenSessionReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionReq) ReadField2 

func (p *TSOpenSessionReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionReq) ReadField3 

func (p *TSOpenSessionReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionReq) ReadField4 

func (p *TSOpenSessionReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionReq) ReadField5 

func (p *TSOpenSessionReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionReq) String 

func (p *TSOpenSessionReq) String() string

func (*TSOpenSessionReq) Write 

func (p *TSOpenSessionReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSOpenSessionResp 

type TSOpenSessionResp struct {
	Status                *common.TSStatus  `thrift:"status,1,required" db:"status" json:"status"`
	ServerProtocolVersion TSProtocolVersion `thrift:"serverProtocolVersion,2,required" db:"serverProtocolVersion" json:"serverProtocolVersion"`
	SessionId             *int64            `thrift:"sessionId,3" db:"sessionId" json:"sessionId,omitempty"`
	Configuration         map[string]string `thrift:"configuration,4" db:"configuration" json:"configuration,omitempty"`
}

Attributes:

  • Status
  • ServerProtocolVersion
  • SessionId
  • Configuration
var IClientRPCServiceOpenSessionResult_Success_DEFAULT *TSOpenSessionResp

func NewTSOpenSessionResp 

func NewTSOpenSessionResp() *TSOpenSessionResp

func (*TSOpenSessionResp) Equals 

func (p *TSOpenSessionResp) Equals(other *TSOpenSessionResp) bool

func (*TSOpenSessionResp) GetConfiguration 

func (p *TSOpenSessionResp) GetConfiguration() map[string]string

func (*TSOpenSessionResp) GetServerProtocolVersion 

func (p *TSOpenSessionResp) GetServerProtocolVersion() TSProtocolVersion

func (*TSOpenSessionResp) GetSessionId 

func (p *TSOpenSessionResp) GetSessionId() int64

func (*TSOpenSessionResp) GetStatus 

func (p *TSOpenSessionResp) GetStatus() *common.TSStatus

func (*TSOpenSessionResp) IsSetConfiguration 

func (p *TSOpenSessionResp) IsSetConfiguration() bool

func (*TSOpenSessionResp) IsSetSessionId 

func (p *TSOpenSessionResp) IsSetSessionId() bool

func (*TSOpenSessionResp) IsSetStatus 

func (p *TSOpenSessionResp) IsSetStatus() bool

func (*TSOpenSessionResp) Read 

func (p *TSOpenSessionResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionResp) ReadField1 

func (p *TSOpenSessionResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionResp) ReadField2 

func (p *TSOpenSessionResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionResp) ReadField3 

func (p *TSOpenSessionResp) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionResp) ReadField4 

func (p *TSOpenSessionResp) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSOpenSessionResp) String 

func (p *TSOpenSessionResp) String() string

func (*TSOpenSessionResp) Write 

func (p *TSOpenSessionResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSProtocolVersion 

type TSProtocolVersion int64
const (
	TSProtocolVersion_IOTDB_SERVICE_PROTOCOL_V1 TSProtocolVersion = 0
	TSProtocolVersion_IOTDB_SERVICE_PROTOCOL_V2 TSProtocolVersion = 1
	TSProtocolVersion_IOTDB_SERVICE_PROTOCOL_V3 TSProtocolVersion = 2
)

func TSProtocolVersionFromString 

func TSProtocolVersionFromString(s string) (TSProtocolVersion, error)

func TSProtocolVersionPtr 

func TSProtocolVersionPtr(v TSProtocolVersion) *TSProtocolVersion

func (TSProtocolVersion) MarshalText 

func (p TSProtocolVersion) MarshalText() ([]byte, error)

func (*TSProtocolVersion) Scan 

func (p *TSProtocolVersion) Scan(value interface{}) error

func (TSProtocolVersion) String 

func (p TSProtocolVersion) String() string

func (*TSProtocolVersion) UnmarshalText 

func (p *TSProtocolVersion) UnmarshalText(text []byte) error

func (*TSProtocolVersion) Value 

func (p *TSProtocolVersion) Value() (driver.Value, error)

type TSPruneSchemaTemplateReq 

type TSPruneSchemaTemplateReq struct {
	SessionId int64  `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Name      string `thrift:"name,2,required" db:"name" json:"name"`
	Path      string `thrift:"path,3,required" db:"path" json:"path"`
}

Attributes:

  • SessionId
  • Name
  • Path
var IClientRPCServicePruneSchemaTemplateArgs_Req_DEFAULT *TSPruneSchemaTemplateReq

func NewTSPruneSchemaTemplateReq 

func NewTSPruneSchemaTemplateReq() *TSPruneSchemaTemplateReq

func (*TSPruneSchemaTemplateReq) Equals 

func (p *TSPruneSchemaTemplateReq) Equals(other *TSPruneSchemaTemplateReq) bool

func (*TSPruneSchemaTemplateReq) GetName 

func (p *TSPruneSchemaTemplateReq) GetName() string

func (*TSPruneSchemaTemplateReq) GetPath 

func (p *TSPruneSchemaTemplateReq) GetPath() string

func (*TSPruneSchemaTemplateReq) GetSessionId 

func (p *TSPruneSchemaTemplateReq) GetSessionId() int64

func (*TSPruneSchemaTemplateReq) Read 

func (p *TSPruneSchemaTemplateReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSPruneSchemaTemplateReq) ReadField1 

func (p *TSPruneSchemaTemplateReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSPruneSchemaTemplateReq) ReadField2 

func (p *TSPruneSchemaTemplateReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSPruneSchemaTemplateReq) ReadField3 

func (p *TSPruneSchemaTemplateReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSPruneSchemaTemplateReq) String 

func (p *TSPruneSchemaTemplateReq) String() string

func (*TSPruneSchemaTemplateReq) Write 

func (p *TSPruneSchemaTemplateReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSQueryDataSet 

type TSQueryDataSet struct {
	Time       []byte   `thrift:"time,1,required" db:"time" json:"time"`
	ValueList  [][]byte `thrift:"valueList,2,required" db:"valueList" json:"valueList"`
	BitmapList [][]byte `thrift:"bitmapList,3,required" db:"bitmapList" json:"bitmapList"`
}

Attributes:

  • Time
  • ValueList
  • BitmapList
var TSExecuteStatementResp_QueryDataSet_DEFAULT *TSQueryDataSet
var TSFetchResultsResp_QueryDataSet_DEFAULT *TSQueryDataSet

func NewTSQueryDataSet 

func NewTSQueryDataSet() *TSQueryDataSet

func (*TSQueryDataSet) Equals 

func (p *TSQueryDataSet) Equals(other *TSQueryDataSet) bool

func (*TSQueryDataSet) GetBitmapList 

func (p *TSQueryDataSet) GetBitmapList() [][]byte

func (*TSQueryDataSet) GetTime 

func (p *TSQueryDataSet) GetTime() []byte

func (*TSQueryDataSet) GetValueList 

func (p *TSQueryDataSet) GetValueList() [][]byte

func (*TSQueryDataSet) Read 

func (p *TSQueryDataSet) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryDataSet) ReadField1 

func (p *TSQueryDataSet) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryDataSet) ReadField2 

func (p *TSQueryDataSet) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryDataSet) ReadField3 

func (p *TSQueryDataSet) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryDataSet) String 

func (p *TSQueryDataSet) String() string

func (*TSQueryDataSet) Write 

func (p *TSQueryDataSet) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSQueryNonAlignDataSet 

type TSQueryNonAlignDataSet struct {
	TimeList  [][]byte `thrift:"timeList,1,required" db:"timeList" json:"timeList"`
	ValueList [][]byte `thrift:"valueList,2,required" db:"valueList" json:"valueList"`
}

Attributes:

  • TimeList
  • ValueList
var TSExecuteStatementResp_NonAlignQueryDataSet_DEFAULT *TSQueryNonAlignDataSet
var TSFetchResultsResp_NonAlignQueryDataSet_DEFAULT *TSQueryNonAlignDataSet

func NewTSQueryNonAlignDataSet 

func NewTSQueryNonAlignDataSet() *TSQueryNonAlignDataSet

func (*TSQueryNonAlignDataSet) Equals 

func (p *TSQueryNonAlignDataSet) Equals(other *TSQueryNonAlignDataSet) bool

func (*TSQueryNonAlignDataSet) GetTimeList 

func (p *TSQueryNonAlignDataSet) GetTimeList() [][]byte

func (*TSQueryNonAlignDataSet) GetValueList 

func (p *TSQueryNonAlignDataSet) GetValueList() [][]byte

func (*TSQueryNonAlignDataSet) Read 

func (p *TSQueryNonAlignDataSet) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryNonAlignDataSet) ReadField1 

func (p *TSQueryNonAlignDataSet) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryNonAlignDataSet) ReadField2 

func (p *TSQueryNonAlignDataSet) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryNonAlignDataSet) String 

func (p *TSQueryNonAlignDataSet) String() string

func (*TSQueryNonAlignDataSet) Write 

func (p *TSQueryNonAlignDataSet) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSQueryTemplateReq 

type TSQueryTemplateReq struct {
	SessionId   int64   `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Name        string  `thrift:"name,2,required" db:"name" json:"name"`
	QueryType   int32   `thrift:"queryType,3,required" db:"queryType" json:"queryType"`
	Measurement *string `thrift:"measurement,4" db:"measurement" json:"measurement,omitempty"`
}

Attributes:

  • SessionId
  • Name
  • QueryType
  • Measurement
var IClientRPCServiceQuerySchemaTemplateArgs_Req_DEFAULT *TSQueryTemplateReq

func NewTSQueryTemplateReq 

func NewTSQueryTemplateReq() *TSQueryTemplateReq

func (*TSQueryTemplateReq) Equals 

func (p *TSQueryTemplateReq) Equals(other *TSQueryTemplateReq) bool

func (*TSQueryTemplateReq) GetMeasurement 

func (p *TSQueryTemplateReq) GetMeasurement() string

func (*TSQueryTemplateReq) GetName 

func (p *TSQueryTemplateReq) GetName() string

func (*TSQueryTemplateReq) GetQueryType 

func (p *TSQueryTemplateReq) GetQueryType() int32

func (*TSQueryTemplateReq) GetSessionId 

func (p *TSQueryTemplateReq) GetSessionId() int64

func (*TSQueryTemplateReq) IsSetMeasurement 

func (p *TSQueryTemplateReq) IsSetMeasurement() bool

func (*TSQueryTemplateReq) Read 

func (p *TSQueryTemplateReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateReq) ReadField1 

func (p *TSQueryTemplateReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateReq) ReadField2 

func (p *TSQueryTemplateReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateReq) ReadField3 

func (p *TSQueryTemplateReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateReq) ReadField4 

func (p *TSQueryTemplateReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateReq) String 

func (p *TSQueryTemplateReq) String() string

func (*TSQueryTemplateReq) Write 

func (p *TSQueryTemplateReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSQueryTemplateResp 

type TSQueryTemplateResp struct {
	Status       *common.TSStatus `thrift:"status,1,required" db:"status" json:"status"`
	QueryType    int32            `thrift:"queryType,2,required" db:"queryType" json:"queryType"`
	Result_      *bool            `thrift:"result,3" db:"result" json:"result,omitempty"`
	Count        *int32           `thrift:"count,4" db:"count" json:"count,omitempty"`
	Measurements []string         `thrift:"measurements,5" db:"measurements" json:"measurements,omitempty"`
}

Attributes:

  • Status
  • QueryType
  • Result_
  • Count
  • Measurements
var IClientRPCServiceQuerySchemaTemplateResult_Success_DEFAULT *TSQueryTemplateResp

func NewTSQueryTemplateResp 

func NewTSQueryTemplateResp() *TSQueryTemplateResp

func (*TSQueryTemplateResp) Equals 

func (p *TSQueryTemplateResp) Equals(other *TSQueryTemplateResp) bool

func (*TSQueryTemplateResp) GetCount 

func (p *TSQueryTemplateResp) GetCount() int32

func (*TSQueryTemplateResp) GetMeasurements 

func (p *TSQueryTemplateResp) GetMeasurements() []string

func (*TSQueryTemplateResp) GetQueryType 

func (p *TSQueryTemplateResp) GetQueryType() int32

func (*TSQueryTemplateResp) GetResult_ 

func (p *TSQueryTemplateResp) GetResult_() bool

func (*TSQueryTemplateResp) GetStatus 

func (p *TSQueryTemplateResp) GetStatus() *common.TSStatus

func (*TSQueryTemplateResp) IsSetCount 

func (p *TSQueryTemplateResp) IsSetCount() bool

func (*TSQueryTemplateResp) IsSetMeasurements 

func (p *TSQueryTemplateResp) IsSetMeasurements() bool

func (*TSQueryTemplateResp) IsSetResult_ 

func (p *TSQueryTemplateResp) IsSetResult_() bool

func (*TSQueryTemplateResp) IsSetStatus 

func (p *TSQueryTemplateResp) IsSetStatus() bool

func (*TSQueryTemplateResp) Read 

func (p *TSQueryTemplateResp) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateResp) ReadField1 

func (p *TSQueryTemplateResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateResp) ReadField2 

func (p *TSQueryTemplateResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateResp) ReadField3 

func (p *TSQueryTemplateResp) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateResp) ReadField4 

func (p *TSQueryTemplateResp) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateResp) ReadField5 

func (p *TSQueryTemplateResp) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSQueryTemplateResp) String 

func (p *TSQueryTemplateResp) String() string

func (*TSQueryTemplateResp) Write 

func (p *TSQueryTemplateResp) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSRawDataQueryReq 

type TSRawDataQueryReq struct {
	SessionId           int64    `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	Paths               []string `thrift:"paths,2,required" db:"paths" json:"paths"`
	FetchSize           *int32   `thrift:"fetchSize,3" db:"fetchSize" json:"fetchSize,omitempty"`
	StartTime           int64    `thrift:"startTime,4,required" db:"startTime" json:"startTime"`
	EndTime             int64    `thrift:"endTime,5,required" db:"endTime" json:"endTime"`
	StatementId         int64    `thrift:"statementId,6,required" db:"statementId" json:"statementId"`
	EnableRedirectQuery *bool    `thrift:"enableRedirectQuery,7" db:"enableRedirectQuery" json:"enableRedirectQuery,omitempty"`
	JdbcQuery           *bool    `thrift:"jdbcQuery,8" db:"jdbcQuery" json:"jdbcQuery,omitempty"`
	Timeout             *int64   `thrift:"timeout,9" db:"timeout" json:"timeout,omitempty"`
	LegalPathNodes      *bool    `thrift:"legalPathNodes,10" db:"legalPathNodes" json:"legalPathNodes,omitempty"`
}

Attributes:

  • SessionId
  • Paths
  • FetchSize
  • StartTime
  • EndTime
  • StatementId
  • EnableRedirectQuery
  • JdbcQuery
  • Timeout
  • LegalPathNodes
var IClientRPCServiceExecuteRawDataQueryArgs_Req_DEFAULT *TSRawDataQueryReq
var IClientRPCServiceExecuteRawDataQueryV2Args_Req_DEFAULT *TSRawDataQueryReq

func NewTSRawDataQueryReq 

func NewTSRawDataQueryReq() *TSRawDataQueryReq

func (*TSRawDataQueryReq) Equals 

func (p *TSRawDataQueryReq) Equals(other *TSRawDataQueryReq) bool

func (*TSRawDataQueryReq) GetEnableRedirectQuery 

func (p *TSRawDataQueryReq) GetEnableRedirectQuery() bool

func (*TSRawDataQueryReq) GetEndTime 

func (p *TSRawDataQueryReq) GetEndTime() int64

func (*TSRawDataQueryReq) GetFetchSize 

func (p *TSRawDataQueryReq) GetFetchSize() int32

func (*TSRawDataQueryReq) GetJdbcQuery 

func (p *TSRawDataQueryReq) GetJdbcQuery() bool

func (*TSRawDataQueryReq) GetLegalPathNodes 

func (p *TSRawDataQueryReq) GetLegalPathNodes() bool

func (*TSRawDataQueryReq) GetPaths 

func (p *TSRawDataQueryReq) GetPaths() []string

func (*TSRawDataQueryReq) GetSessionId 

func (p *TSRawDataQueryReq) GetSessionId() int64

func (*TSRawDataQueryReq) GetStartTime 

func (p *TSRawDataQueryReq) GetStartTime() int64

func (*TSRawDataQueryReq) GetStatementId 

func (p *TSRawDataQueryReq) GetStatementId() int64

func (*TSRawDataQueryReq) GetTimeout 

func (p *TSRawDataQueryReq) GetTimeout() int64

func (*TSRawDataQueryReq) IsSetEnableRedirectQuery 

func (p *TSRawDataQueryReq) IsSetEnableRedirectQuery() bool

func (*TSRawDataQueryReq) IsSetFetchSize 

func (p *TSRawDataQueryReq) IsSetFetchSize() bool

func (*TSRawDataQueryReq) IsSetJdbcQuery 

func (p *TSRawDataQueryReq) IsSetJdbcQuery() bool

func (*TSRawDataQueryReq) IsSetLegalPathNodes 

func (p *TSRawDataQueryReq) IsSetLegalPathNodes() bool

func (*TSRawDataQueryReq) IsSetTimeout 

func (p *TSRawDataQueryReq) IsSetTimeout() bool

func (*TSRawDataQueryReq) Read 

func (p *TSRawDataQueryReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField1 

func (p *TSRawDataQueryReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField10 

func (p *TSRawDataQueryReq) ReadField10(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField2 

func (p *TSRawDataQueryReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField3 

func (p *TSRawDataQueryReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField4 

func (p *TSRawDataQueryReq) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField5 

func (p *TSRawDataQueryReq) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField6 

func (p *TSRawDataQueryReq) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField7 

func (p *TSRawDataQueryReq) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField8 

func (p *TSRawDataQueryReq) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) ReadField9 

func (p *TSRawDataQueryReq) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSRawDataQueryReq) String 

func (p *TSRawDataQueryReq) String() string

func (*TSRawDataQueryReq) Write 

func (p *TSRawDataQueryReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSSetSchemaTemplateReq 

type TSSetSchemaTemplateReq struct {
	SessionId    int64  `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	TemplateName string `thrift:"templateName,2,required" db:"templateName" json:"templateName"`
	PrefixPath   string `thrift:"prefixPath,3,required" db:"prefixPath" json:"prefixPath"`
}

Attributes:

  • SessionId
  • TemplateName
  • PrefixPath
var IClientRPCServiceSetSchemaTemplateArgs_Req_DEFAULT *TSSetSchemaTemplateReq

func NewTSSetSchemaTemplateReq 

func NewTSSetSchemaTemplateReq() *TSSetSchemaTemplateReq

func (*TSSetSchemaTemplateReq) Equals 

func (p *TSSetSchemaTemplateReq) Equals(other *TSSetSchemaTemplateReq) bool

func (*TSSetSchemaTemplateReq) GetPrefixPath 

func (p *TSSetSchemaTemplateReq) GetPrefixPath() string

func (*TSSetSchemaTemplateReq) GetSessionId 

func (p *TSSetSchemaTemplateReq) GetSessionId() int64

func (*TSSetSchemaTemplateReq) GetTemplateName 

func (p *TSSetSchemaTemplateReq) GetTemplateName() string

func (*TSSetSchemaTemplateReq) Read 

func (p *TSSetSchemaTemplateReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSSetSchemaTemplateReq) ReadField1 

func (p *TSSetSchemaTemplateReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSSetSchemaTemplateReq) ReadField2 

func (p *TSSetSchemaTemplateReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSSetSchemaTemplateReq) ReadField3 

func (p *TSSetSchemaTemplateReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSSetSchemaTemplateReq) String 

func (p *TSSetSchemaTemplateReq) String() string

func (*TSSetSchemaTemplateReq) Write 

func (p *TSSetSchemaTemplateReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSSetTimeZoneReq 

type TSSetTimeZoneReq struct {
	SessionId int64  `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	TimeZone  string `thrift:"timeZone,2,required" db:"timeZone" json:"timeZone"`
}

Attributes:

  • SessionId
  • TimeZone
var IClientRPCServiceSetTimeZoneArgs_Req_DEFAULT *TSSetTimeZoneReq

func NewTSSetTimeZoneReq 

func NewTSSetTimeZoneReq() *TSSetTimeZoneReq

func (*TSSetTimeZoneReq) Equals 

func (p *TSSetTimeZoneReq) Equals(other *TSSetTimeZoneReq) bool

func (*TSSetTimeZoneReq) GetSessionId 

func (p *TSSetTimeZoneReq) GetSessionId() int64

func (*TSSetTimeZoneReq) GetTimeZone 

func (p *TSSetTimeZoneReq) GetTimeZone() string

func (*TSSetTimeZoneReq) Read 

func (p *TSSetTimeZoneReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSSetTimeZoneReq) ReadField1 

func (p *TSSetTimeZoneReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSSetTimeZoneReq) ReadField2 

func (p *TSSetTimeZoneReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSSetTimeZoneReq) String 

func (p *TSSetTimeZoneReq) String() string

func (*TSSetTimeZoneReq) Write 

func (p *TSSetTimeZoneReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSTracingInfo 

type TSTracingInfo struct {
	ActivityList            []string `thrift:"activityList,1,required" db:"activityList" json:"activityList"`
	ElapsedTimeList         []int64  `thrift:"elapsedTimeList,2,required" db:"elapsedTimeList" json:"elapsedTimeList"`
	SeriesPathNum           *int32   `thrift:"seriesPathNum,3" db:"seriesPathNum" json:"seriesPathNum,omitempty"`
	SeqFileNum              *int32   `thrift:"seqFileNum,4" db:"seqFileNum" json:"seqFileNum,omitempty"`
	UnSeqFileNum            *int32   `thrift:"unSeqFileNum,5" db:"unSeqFileNum" json:"unSeqFileNum,omitempty"`
	SequenceChunkNum        *int32   `thrift:"sequenceChunkNum,6" db:"sequenceChunkNum" json:"sequenceChunkNum,omitempty"`
	SequenceChunkPointNum   *int64   `thrift:"sequenceChunkPointNum,7" db:"sequenceChunkPointNum" json:"sequenceChunkPointNum,omitempty"`
	UnsequenceChunkNum      *int32   `thrift:"unsequenceChunkNum,8" db:"unsequenceChunkNum" json:"unsequenceChunkNum,omitempty"`
	UnsequenceChunkPointNum *int64   `thrift:"unsequenceChunkPointNum,9" db:"unsequenceChunkPointNum" json:"unsequenceChunkPointNum,omitempty"`
	TotalPageNum            *int32   `thrift:"totalPageNum,10" db:"totalPageNum" json:"totalPageNum,omitempty"`
	OverlappedPageNum       *int32   `thrift:"overlappedPageNum,11" db:"overlappedPageNum" json:"overlappedPageNum,omitempty"`
}

Attributes:

  • ActivityList
  • ElapsedTimeList
  • SeriesPathNum
  • SeqFileNum
  • UnSeqFileNum
  • SequenceChunkNum
  • SequenceChunkPointNum
  • UnsequenceChunkNum
  • UnsequenceChunkPointNum
  • TotalPageNum
  • OverlappedPageNum
var TSExecuteStatementResp_TracingInfo_DEFAULT *TSTracingInfo

func NewTSTracingInfo 

func NewTSTracingInfo() *TSTracingInfo

func (*TSTracingInfo) Equals 

func (p *TSTracingInfo) Equals(other *TSTracingInfo) bool

func (*TSTracingInfo) GetActivityList 

func (p *TSTracingInfo) GetActivityList() []string

func (*TSTracingInfo) GetElapsedTimeList 

func (p *TSTracingInfo) GetElapsedTimeList() []int64

func (*TSTracingInfo) GetOverlappedPageNum 

func (p *TSTracingInfo) GetOverlappedPageNum() int32

func (*TSTracingInfo) GetSeqFileNum 

func (p *TSTracingInfo) GetSeqFileNum() int32

func (*TSTracingInfo) GetSequenceChunkNum 

func (p *TSTracingInfo) GetSequenceChunkNum() int32

func (*TSTracingInfo) GetSequenceChunkPointNum 

func (p *TSTracingInfo) GetSequenceChunkPointNum() int64

func (*TSTracingInfo) GetSeriesPathNum 

func (p *TSTracingInfo) GetSeriesPathNum() int32

func (*TSTracingInfo) GetTotalPageNum 

func (p *TSTracingInfo) GetTotalPageNum() int32

func (*TSTracingInfo) GetUnSeqFileNum 

func (p *TSTracingInfo) GetUnSeqFileNum() int32

func (*TSTracingInfo) GetUnsequenceChunkNum 

func (p *TSTracingInfo) GetUnsequenceChunkNum() int32

func (*TSTracingInfo) GetUnsequenceChunkPointNum 

func (p *TSTracingInfo) GetUnsequenceChunkPointNum() int64

func (*TSTracingInfo) IsSetOverlappedPageNum 

func (p *TSTracingInfo) IsSetOverlappedPageNum() bool

func (*TSTracingInfo) IsSetSeqFileNum 

func (p *TSTracingInfo) IsSetSeqFileNum() bool

func (*TSTracingInfo) IsSetSequenceChunkNum 

func (p *TSTracingInfo) IsSetSequenceChunkNum() bool

func (*TSTracingInfo) IsSetSequenceChunkPointNum 

func (p *TSTracingInfo) IsSetSequenceChunkPointNum() bool

func (*TSTracingInfo) IsSetSeriesPathNum 

func (p *TSTracingInfo) IsSetSeriesPathNum() bool

func (*TSTracingInfo) IsSetTotalPageNum 

func (p *TSTracingInfo) IsSetTotalPageNum() bool

func (*TSTracingInfo) IsSetUnSeqFileNum 

func (p *TSTracingInfo) IsSetUnSeqFileNum() bool

func (*TSTracingInfo) IsSetUnsequenceChunkNum 

func (p *TSTracingInfo) IsSetUnsequenceChunkNum() bool

func (*TSTracingInfo) IsSetUnsequenceChunkPointNum 

func (p *TSTracingInfo) IsSetUnsequenceChunkPointNum() bool

func (*TSTracingInfo) Read 

func (p *TSTracingInfo) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField1 

func (p *TSTracingInfo) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField10 

func (p *TSTracingInfo) ReadField10(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField11 

func (p *TSTracingInfo) ReadField11(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField2 

func (p *TSTracingInfo) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField3 

func (p *TSTracingInfo) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField4 

func (p *TSTracingInfo) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField5 

func (p *TSTracingInfo) ReadField5(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField6 

func (p *TSTracingInfo) ReadField6(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField7 

func (p *TSTracingInfo) ReadField7(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField8 

func (p *TSTracingInfo) ReadField8(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) ReadField9 

func (p *TSTracingInfo) ReadField9(ctx context.Context, iprot thrift.TProtocol) error

func (*TSTracingInfo) String 

func (p *TSTracingInfo) String() string

func (*TSTracingInfo) Write 

func (p *TSTracingInfo) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSUnsetSchemaTemplateReq 

type TSUnsetSchemaTemplateReq struct {
	SessionId    int64  `thrift:"sessionId,1,required" db:"sessionId" json:"sessionId"`
	PrefixPath   string `thrift:"prefixPath,2,required" db:"prefixPath" json:"prefixPath"`
	TemplateName string `thrift:"templateName,3,required" db:"templateName" json:"templateName"`
}

Attributes:

  • SessionId
  • PrefixPath
  • TemplateName
var IClientRPCServiceUnsetSchemaTemplateArgs_Req_DEFAULT *TSUnsetSchemaTemplateReq

func NewTSUnsetSchemaTemplateReq 

func NewTSUnsetSchemaTemplateReq() *TSUnsetSchemaTemplateReq

func (*TSUnsetSchemaTemplateReq) Equals 

func (p *TSUnsetSchemaTemplateReq) Equals(other *TSUnsetSchemaTemplateReq) bool

func (*TSUnsetSchemaTemplateReq) GetPrefixPath 

func (p *TSUnsetSchemaTemplateReq) GetPrefixPath() string

func (*TSUnsetSchemaTemplateReq) GetSessionId 

func (p *TSUnsetSchemaTemplateReq) GetSessionId() int64

func (*TSUnsetSchemaTemplateReq) GetTemplateName 

func (p *TSUnsetSchemaTemplateReq) GetTemplateName() string

func (*TSUnsetSchemaTemplateReq) Read 

func (p *TSUnsetSchemaTemplateReq) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSUnsetSchemaTemplateReq) ReadField1 

func (p *TSUnsetSchemaTemplateReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSUnsetSchemaTemplateReq) ReadField2 

func (p *TSUnsetSchemaTemplateReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSUnsetSchemaTemplateReq) ReadField3 

func (p *TSUnsetSchemaTemplateReq) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSUnsetSchemaTemplateReq) String 

func (p *TSUnsetSchemaTemplateReq) String() string

func (*TSUnsetSchemaTemplateReq) Write 

func (p *TSUnsetSchemaTemplateReq) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSyncIdentityInfo 

type TSyncIdentityInfo struct {
	PipeName   string `thrift:"pipeName,1,required" db:"pipeName" json:"pipeName"`
	CreateTime int64  `thrift:"createTime,2,required" db:"createTime" json:"createTime"`
	Version    string `thrift:"version,3,required" db:"version" json:"version"`
	Database   string `thrift:"database,4,required" db:"database" json:"database"`
}

Attributes:

  • PipeName
  • CreateTime
  • Version
  • Database
var IClientRPCServiceHandshakeArgs_Info_DEFAULT *TSyncIdentityInfo

func NewTSyncIdentityInfo 

func NewTSyncIdentityInfo() *TSyncIdentityInfo

func (*TSyncIdentityInfo) Equals 

func (p *TSyncIdentityInfo) Equals(other *TSyncIdentityInfo) bool

func (*TSyncIdentityInfo) GetCreateTime 

func (p *TSyncIdentityInfo) GetCreateTime() int64

func (*TSyncIdentityInfo) GetDatabase 

func (p *TSyncIdentityInfo) GetDatabase() string

func (*TSyncIdentityInfo) GetPipeName 

func (p *TSyncIdentityInfo) GetPipeName() string

func (*TSyncIdentityInfo) GetVersion 

func (p *TSyncIdentityInfo) GetVersion() string

func (*TSyncIdentityInfo) Read 

func (p *TSyncIdentityInfo) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSyncIdentityInfo) ReadField1 

func (p *TSyncIdentityInfo) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSyncIdentityInfo) ReadField2 

func (p *TSyncIdentityInfo) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSyncIdentityInfo) ReadField3 

func (p *TSyncIdentityInfo) ReadField3(ctx context.Context, iprot thrift.TProtocol) error

func (*TSyncIdentityInfo) ReadField4 

func (p *TSyncIdentityInfo) ReadField4(ctx context.Context, iprot thrift.TProtocol) error

func (*TSyncIdentityInfo) String 

func (p *TSyncIdentityInfo) String() string

func (*TSyncIdentityInfo) Write 

func (p *TSyncIdentityInfo) Write(ctx context.Context, oprot thrift.TProtocol) error

type TSyncTransportMetaInfo 

type TSyncTransportMetaInfo struct {
	FileName   string `thrift:"fileName,1,required" db:"fileName" json:"fileName"`
	StartIndex int64  `thrift:"startIndex,2,required" db:"startIndex" json:"startIndex"`
}

Attributes:

  • FileName
  • StartIndex
var IClientRPCServiceSendFileArgs_MetaInfo_DEFAULT *TSyncTransportMetaInfo

func NewTSyncTransportMetaInfo 

func NewTSyncTransportMetaInfo() *TSyncTransportMetaInfo

func (*TSyncTransportMetaInfo) Equals 

func (p *TSyncTransportMetaInfo) Equals(other *TSyncTransportMetaInfo) bool

func (*TSyncTransportMetaInfo) GetFileName 

func (p *TSyncTransportMetaInfo) GetFileName() string

func (*TSyncTransportMetaInfo) GetStartIndex 

func (p *TSyncTransportMetaInfo) GetStartIndex() int64

func (*TSyncTransportMetaInfo) Read 

func (p *TSyncTransportMetaInfo) Read(ctx context.Context, iprot thrift.TProtocol) error

func (*TSyncTransportMetaInfo) ReadField1 

func (p *TSyncTransportMetaInfo) ReadField1(ctx context.Context, iprot thrift.TProtocol) error

func (*TSyncTransportMetaInfo) ReadField2 

func (p *TSyncTransportMetaInfo) ReadField2(ctx context.Context, iprot thrift.TProtocol) error

func (*TSyncTransportMetaInfo) String 

func (p *TSyncTransportMetaInfo) String() string

func (*TSyncTransportMetaInfo) Write 

func (p *TSyncTransportMetaInfo) Write(ctx context.Context, oprot thrift.TProtocol) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.