taskflow

package
v0.0.8 Latest Latest
Warning

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

 Go to latest Published: Aug 8, 2024 License: Apache-2.0 Imports: 30 Imported by: 0

Documentation

Overview

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2020 Marvin

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AssessDatabaseColumnNameLengthCheck 

func AssessDatabaseColumnNameLengthCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]SchemaTableColumnNameLengthCheck, ReportSummary, error)

func AssessDatabaseIndexNameLengthCheck 

func AssessDatabaseIndexNameLengthCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]SchemaTableIndexNameLengthCheck, ReportSummary, error)

func AssessDatabaseMaxActiveSessionCount 

func AssessDatabaseMaxActiveSessionCount(databaseS database.IDatabase, schemaNames []string) ([]SchemaActiveSession, ReportSummary, error)

func AssessDatabaseOverview 

func AssessDatabaseOverview(databaseS database.IDatabase, objAssessCompsMap map[string]buildin.BuildinCompatibleRule, reportName, reportUser string) (*ReportOverview, ReportSummary, error)

func AssessDatabasePartitionTableCountsCheck 

func AssessDatabasePartitionTableCountsCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]SchemaPartitionTableCountsCheck, ReportSummary, error)

Oracle Database Check

func AssessDatabaseSchemaCodeOverview 

func AssessDatabaseSchemaCodeOverview(databaseS database.IDatabase, schemaNames []string) ([]SchemaCodeObject, ReportSummary, error)

func AssessDatabaseSchemaColumnTypeCompatible 

func AssessDatabaseSchemaColumnTypeCompatible(databaseS database.IDatabase, schemaNames []string, buildinDatatypeMap map[string]buildin.BuildinDatatypeRule) ([]SchemaColumnTypeCompatibles, ReportSummary, error)

func AssessDatabaseSchemaConstraintTypeCompatible 

func AssessDatabaseSchemaConstraintTypeCompatible(databaseS database.IDatabase, schemaNames []string, objAssessCompsMap map[string]buildin.BuildinCompatibleRule) ([]SchemaConstraintTypeCompatibles, ReportSummary, error)

func AssessDatabaseSchemaDefaultValue 

func AssessDatabaseSchemaDefaultValue(databaseS database.IDatabase, schemaNames []string, defaultValueMap map[string]buildin.BuildinDefaultvalRule) ([]SchemaDefaultValueCompatibles, ReportSummary, error)

func AssessDatabaseSchemaIndexTypeCompatible 

func AssessDatabaseSchemaIndexTypeCompatible(databaseS database.IDatabase, schemaNames []string, objAssessCompsMap map[string]buildin.BuildinCompatibleRule) ([]SchemaIndexTypeCompatibles, ReportSummary, error)

func AssessDatabaseSchemaMaterializedViewOverview 

func AssessDatabaseSchemaMaterializedViewOverview(databaseS database.IDatabase, schemaNames []string) ([]SchemaMaterializedViewObject, ReportSummary, error)

func AssessDatabaseSchemaObjectTypeCompatible 

func AssessDatabaseSchemaObjectTypeCompatible(databaseS database.IDatabase, schemaNames []string, objAssessCompsMap map[string]buildin.BuildinCompatibleRule) ([]SchemaObjectTypeCompatibles, ReportSummary, error)

func AssessDatabaseSchemaOverview 

func AssessDatabaseSchemaOverview(databaseS database.IDatabase, schemaNames []string) ([]SchemaTableSizeData, ReportSummary, error)

Oracle Database Reference

func AssessDatabaseSchemaPartitionTypeCompatible 

func AssessDatabaseSchemaPartitionTypeCompatible(databaseS database.IDatabase, schemaNames []string, objAssessCompsMap map[string]buildin.BuildinCompatibleRule) ([]SchemaPartitionTypeCompatibles, ReportSummary, error)

func AssessDatabaseSchemaSubPartitionTypeCompatible 

func AssessDatabaseSchemaSubPartitionTypeCompatible(databaseS database.IDatabase, schemaNames []string, objAssessCompsMap map[string]buildin.BuildinCompatibleRule) ([]SchemaSubPartitionTypeCompatibles, ReportSummary, error)

func AssessDatabaseSchemaSynonymOverview 

func AssessDatabaseSchemaSynonymOverview(databaseS database.IDatabase, schemaNames []string) ([]SchemaSynonymObject, ReportSummary, error)

func AssessDatabaseSchemaTableAvgRowLengthTOP 

func AssessDatabaseSchemaTableAvgRowLengthTOP(databaseS database.IDatabase, schemaNames []string, top int) ([]SchemaTableAvgRowLengthTOP, ReportSummary, error)

func AssessDatabaseSchemaTableNumberTypeEqualZero 

func AssessDatabaseSchemaTableNumberTypeEqualZero(databaseS database.IDatabase, schemaNames []string, specifyDatatype string) ([]SchemaTableNumberTypeEqualZero, ReportSummary, error)

func AssessDatabaseSchemaTableRowsTOP 

func AssessDatabaseSchemaTableRowsTOP(databaseS database.IDatabase, schemaNames []string, top int) ([]SchemaTableRowsTOP, ReportSummary, error)

func AssessDatabaseSchemaTableTypeCompatible 

func AssessDatabaseSchemaTableTypeCompatible(databaseS database.IDatabase, schemaNames []string, objAssessCompsMap map[string]buildin.BuildinCompatibleRule) ([]SchemaTableTypeCompatibles, ReportSummary, error)

func AssessDatabaseSchemaTemporaryTableCompatible 

func AssessDatabaseSchemaTemporaryTableCompatible(databaseS database.IDatabase, schemaNames []string, objAssessCompsMap map[string]buildin.BuildinCompatibleRule) ([]SchemaTemporaryTableTypeCompatibles, ReportSummary, error)

func AssessDatabaseSchemaViewTypeCompatible 

func AssessDatabaseSchemaViewTypeCompatible(databaseS database.IDatabase, schemaNames []string, objAssessCompsMap map[string]buildin.BuildinCompatibleRule) ([]SchemaViewTypeCompatibles, ReportSummary, error)

func AssessDatabaseSequenceNameLengthCheck 

func AssessDatabaseSequenceNameLengthCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]SchemaSequenceNameLengthCheck, ReportSummary, error)

func AssessDatabaseTableColumnCountsCheck 

func AssessDatabaseTableColumnCountsCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]SchemaTableColumnCountsCheck, ReportSummary, error)

func AssessDatabaseTableIndexCountsCheck 

func AssessDatabaseTableIndexCountsCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]SchemaTableIndexCountsCheck, ReportSummary, error)

func AssessDatabaseTableIndexRowLengthCheck 

func AssessDatabaseTableIndexRowLengthCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]SchemaTableIndexRowLengthCheck, ReportSummary, error)

func AssessDatabaseTableNameLengthCheck 

func AssessDatabaseTableNameLengthCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]SchemaTableNameLengthCheck, ReportSummary, error)

func AssessDatabaseTableRowLengthMBCheck 

func AssessDatabaseTableRowLengthMBCheck(databaseS database.IDatabase, schemaNames []string, limitMB int) ([]SchemaTableRowLengthCheck, ReportSummary, error)

func AssessDatabaseUsernameLengthCheck 

func AssessDatabaseUsernameLengthCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]UsernameLengthCheck, ReportSummary, error)

func AssessDatabaseViewNameLengthCheck 

func AssessDatabaseViewNameLengthCheck(databaseS database.IDatabase, schemaNames []string, limit int) ([]SchemaViewNameLengthCheck, ReportSummary, error)

func GenNewHTMLReport 

func GenNewHTMLReport(report *Report, file *os.File) error

func GetAssessDatabaseCheckResult 

func GetAssessDatabaseCheckResult(databaseS database.IDatabase, schemaNames []string) (*ReportCheck, *ReportSummary, error)

func GetAssessDatabaseCompatibleResult 

func GetAssessDatabaseCompatibleResult(databaseS database.IDatabase, schemaNames []string, objAssessCompsMap map[string]buildin.BuildinCompatibleRule, buildDatatypeMap map[string]buildin.BuildinDatatypeRule, defaultValuesMap map[string]buildin.BuildinDefaultvalRule) (*ReportCompatible, *ReportSummary, error)

func GetAssessDatabaseOverviewResult 

func GetAssessDatabaseOverviewResult(databaseS database.IDatabase, objAssessCompsMap map[string]buildin.BuildinCompatibleRule, reportUser, reportName string) (*ReportOverview, ReportSummary, error)

func GetAssessDatabaseRelatedResult 

func GetAssessDatabaseRelatedResult(databaseS database.IDatabase, schemaNames []string) (*ReportRelated, *ReportSummary, error)

Types

type AssessMigrateFile 

type AssessMigrateFile struct {
	Ctx        context.Context `json:"-"`
	Mutex      *sync.Mutex     `json:"-"`
	CompFile   *os.File        `json:"-"`
	CompWriter *bufio.Writer   `json:"-"`
	TaskName   string          `json:"taskName"`
	TaskFlow   string          `json:"taskFlow"`
	OutputDir  string          `json:"outputDir"`
}

func NewAssessMigrateFile 

func NewAssessMigrateFile(ctx context.Context,
	taskName, taskFlow, outputDir string) *AssessMigrateFile

func (*AssessMigrateFile) Close 

func (s *AssessMigrateFile) Close() error

func (*AssessMigrateFile) InitFile 

func (s *AssessMigrateFile) InitFile() error

func (*AssessMigrateFile) SyncFile 

func (s *AssessMigrateFile) SyncFile() error

type AssessMigrateTask 

type AssessMigrateTask struct {
	Ctx         context.Context
	Task        *task.Task
	DatasourceS *datasource.Datasource
	DatasourceT *datasource.Datasource
	TaskParams  *pb.AssessMigrateParam
	DBTypeS     string
	DBTypeT     string
}

func (*AssessMigrateTask) InitAssessMigrateTask 

func (amt *AssessMigrateTask) InitAssessMigrateTask() error

func (*AssessMigrateTask) Start 

func (amt *AssessMigrateTask) Start() error

type CsvMigrateTask 

type CsvMigrateTask struct {
	Ctx         context.Context
	Task        *task.Task
	DatasourceS *datasource.Datasource
	DatasourceT *datasource.Datasource
	TaskParams  *pb.CsvMigrateParam
}

func (*CsvMigrateTask) InitCsvMigrateTask 

func (cmt *CsvMigrateTask) InitCsvMigrateTask(databaseS database.IDatabase, dbVersion string, schemaRoute *rule.SchemaRouteRule) error

func (*CsvMigrateTask) Start 

func (cmt *CsvMigrateTask) Start() error

type DataScanTask 

type DataScanTask struct {
	Ctx         context.Context
	Task        *task.Task
	DatasourceS *datasource.Datasource
	DatasourceT *datasource.Datasource
	TaskParams  *pb.DataScanParam
}

func (*DataScanTask) Start 

func (dst *DataScanTask) Start() error

type Report 

type Report struct {
	*ReportOverview
	*ReportSummary
	*ReportCompatible
	*ReportCheck
	*ReportRelated
}

func (*Report) String 

func (r *Report) String() string

type ReportCheck 

type ReportCheck struct {
	ListSchemaPartitionTableCountsCheck  []SchemaPartitionTableCountsCheck  `json:"list_schema_partition_table_counts_check"`
	ListSchemaTableRowLengthCheck        []SchemaTableRowLengthCheck        `json:"list_schema_table_row_length_check"`
	ListSchemaTableIndexRowLengthCheck   []SchemaTableIndexRowLengthCheck   `json:"list_schema_table_index_row_length_check"`
	ListSchemaTableColumnCountsCheck     []SchemaTableColumnCountsCheck     `json:"list_schema_table_column_counts_check"`
	ListSchemaIndexCountsCheck           []SchemaTableIndexCountsCheck      `json:"list_schema_index_counts_check"`
	ListUsernameLengthCheck              []UsernameLengthCheck              `json:"list_username_length_check"`
	ListSchemaTableNameLengthCheck       []SchemaTableNameLengthCheck       `json:"list_schema_table_name_length_check"`
	ListSchemaTableColumnNameLengthCheck []SchemaTableColumnNameLengthCheck `json:"list_schema_table_column_name_length_check"`
	ListSchemaTableIndexNameLengthCheck  []SchemaTableIndexNameLengthCheck  `json:"list_schema_table_index_name_length_check"`
	ListSchemaViewNameLengthCheck        []SchemaViewNameLengthCheck        `json:"list_schema_view_name_length_check"`
	ListSchemaSequenceNameLengthCheck    []SchemaSequenceNameLengthCheck    `json:"list_schema_sequence_name_length_check"`
}

func (*ReportCheck) String 

func (rc *ReportCheck) String() string

type ReportCompatible 

type ReportCompatible struct {
	ListSchemaTableTypeCompatibles          []SchemaTableTypeCompatibles          `json:"list_schema_table_type_compatibles"`
	ListSchemaColumnTypeCompatibles         []SchemaColumnTypeCompatibles         `json:"list_schema_column_type_compatibles"`
	ListSchemaConstraintTypeCompatibles     []SchemaConstraintTypeCompatibles     `json:"list_schema_constraint_type_compatibles"`
	ListSchemaIndexTypeCompatibles          []SchemaIndexTypeCompatibles          `json:"list_schema_index_type_compatibles"`
	ListSchemaDefaultValueCompatibles       []SchemaDefaultValueCompatibles       `json:"list_schema_default_value_compatibles"`
	ListSchemaViewTypeCompatibles           []SchemaViewTypeCompatibles           `json:"list_schema_view_type_compatibles"`
	ListSchemaObjectTypeCompatibles         []SchemaObjectTypeCompatibles         `json:"list_schema_object_type_compatibles"`
	ListSchemaPartitionTypeCompatibles      []SchemaPartitionTypeCompatibles      `json:"list_schema_partition_type_compatibles"`
	ListSchemaSubPartitionTypeCompatibles   []SchemaSubPartitionTypeCompatibles   `json:"list_schema_sub_partition_type_compatibles"`
	ListSchemaTemporaryTableTypeCompatibles []SchemaTemporaryTableTypeCompatibles `json:"list_schema_temporary_table_type_compatibles"`
}

func (*ReportCompatible) String 

func (sc *ReportCompatible) String() string

type ReportOverview 

type ReportOverview struct {
	ReportName        string `json:"report_name"`
	ReportUser        string `json:"report_user"`
	HostName          string `json:"host_name"`
	PlatformName      string `json:"platform_name"`
	DBName            string `json:"db_name"`
	DBVersion         string `json:"db_version"`
	GlobalDBName      string `json:"global_db_name"`
	ClusterDB         string `json:"cluster_db"`
	ClusterDBInstance string `json:"cluster_db_instance"`
	InstanceName      string `json:"instance_name"`
	InstanceNumber    string `json:"instance_number"`
	ThreadNumber      string `json:"thread_number"`
	BlockSize         string `json:"block_size"`
	TotalUsedSize     string `json:"total_used_size"`
	HostCPUS          string `json:"host_cpus"`
	HostMem           string `json:"host_mem"`
	CharacterSet      string `json:"character_set"`
}

func (*ReportOverview) String 

func (ro *ReportOverview) String() string

type ReportRelated 

type ReportRelated struct {
	ListSchemaActiveSession            []SchemaActiveSession            `json:"list_schema_active_session"`
	ListSchemaTableSizeData            []SchemaTableSizeData            `json:"list_schema_table_size_data"`
	ListSchemaTableRowsTOP             []SchemaTableRowsTOP             `json:"list_schema_table_rows_top"`
	ListSchemaCodeObject               []SchemaCodeObject               `json:"list_schema_code_object"`
	ListSchemaSynonymObject            []SchemaSynonymObject            `json:"list_schema_synonym_object"`
	ListSchemaMaterializedViewObject   []SchemaMaterializedViewObject   `json:"list_schema_materialized_view_object"`
	ListSchemaTableAvgRowLengthTOP     []SchemaTableAvgRowLengthTOP     `json:"list_schema_table_avg_row_length_top"`
	ListSchemaTableNumberTypeEqualZero []SchemaTableNumberTypeEqualZero `json:"list_schema_table_number_type_equal_zero"`
}

func (*ReportRelated) String 

func (rr *ReportRelated) String() string

type ReportSummary 

type ReportSummary struct {
	AssessType    string `json:"assess_type"`
	AssessName    string `json:"assess_name"`
	AssessTotal   int    `json:"assess_total"`
	Compatible    int    `json:"compatible"`
	Incompatible  int    `json:"incompatible"`
	Convertible   int    `json:"convertible"`
	InConvertible int    `json:"inconvertible"`
}

func (*ReportSummary) String 

func (ro *ReportSummary) String() string

type SchemaActiveSession 

type SchemaActiveSession struct {
	Rownum         string `json:"rownum"`
	DBID           string `json:"dbid"`
	InstanceNumber string `json:"instance_number"`
	SampleID       string `json:"sample_id"`
	SampleTime     string `json:"sample_time"`
	SessionCounts  string `json:"session_counts"`
}

func (*SchemaActiveSession) String 

func (ro *SchemaActiveSession) String() string

type SchemaCodeObject 

type SchemaCodeObject struct {
	Schema     string `json:"schema"`
	ObjectName string `json:"object_name"`
	ObjectType string `json:"object_type"`
	Lines      string `json:"lines"`
}

func (*SchemaCodeObject) String 

func (ro *SchemaCodeObject) String() string

type SchemaColumnTypeCompatibles 

type SchemaColumnTypeCompatibles struct {
	Schema        string `json:"schema"`
	ColumnType    string `json:"column_type"`
	ObjectCounts  string `json:"object_counts"`
	MaxDataLength string `json:"max_data_length"`
	ColumnTypeMap string `json:"column_type_map"`
	IsEquivalent  string `json:"is_equivalent"`
}

func (*SchemaColumnTypeCompatibles) String 

func (sc *SchemaColumnTypeCompatibles) String() string

type SchemaConstraintTypeCompatibles 

type SchemaConstraintTypeCompatibles struct {
	Schema         string `json:"schema"`
	ConstraintType string `json:"constraint_type"`
	ObjectCounts   string `json:"object_counts"`
	IsCompatible   string `json:"is_compatible"`
	IsConvertible  string `json:"is_convertible"`
}

func (*SchemaConstraintTypeCompatibles) String 

func (sc *SchemaConstraintTypeCompatibles) String() string

type SchemaDefaultValueCompatibles 

type SchemaDefaultValueCompatibles struct {
	Schema             string `json:"schema"`
	ColumnDefaultValue string `json:"column_default_value"`
	ObjectCounts       string `json:"object_counts"`
	DefaultValueMap    string `json:"default_value_map"`
	IsCompatible       string `json:"is_compatible"`
	IsConvertible      string `json:"is_convertible"`
}

func (*SchemaDefaultValueCompatibles) String 

func (sc *SchemaDefaultValueCompatibles) String() string

type SchemaIndexTypeCompatibles 

type SchemaIndexTypeCompatibles struct {
	Schema        string `json:"schema"`
	IndexType     string `json:"index_type"`
	ObjectCounts  string `json:"object_counts"`
	IsCompatible  string `json:"is_compatible"`
	IsConvertible string `json:"is_convertible"`
}

func (*SchemaIndexTypeCompatibles) String 

func (sc *SchemaIndexTypeCompatibles) String() string

type SchemaMaterializedViewObject 

type SchemaMaterializedViewObject struct {
	Schema            string `json:"schema"`
	MviewName         string `json:"mview_name"`
	RewriteCapability string `json:"rewrite_capability"`
	RefreshMode       string `json:"refresh_mode"`
	RefreshMethod     string `json:"refresh_method"`
	FastRefreshable   string `json:"fast_refreshable"`
}

func (*SchemaMaterializedViewObject) String 

func (ro *SchemaMaterializedViewObject) String() string

type SchemaObjectTypeCompatibles 

type SchemaObjectTypeCompatibles struct {
	Schema        string `json:"schema"`
	ObjectType    string `json:"object_type"`
	ObjectCounts  string `json:"object_counts"`
	IsCompatible  string `json:"is_compatible"`
	IsConvertible string `json:"is_convertible"`
}

func (*SchemaObjectTypeCompatibles) String 

func (sc *SchemaObjectTypeCompatibles) String() string

type SchemaPartitionTableCountsCheck 

type SchemaPartitionTableCountsCheck struct {
	Schema          string `json:"schema"`
	TableName       string `json:"table_name"`
	PartitionCounts string `json:"partition_counts"`
}

func (*SchemaPartitionTableCountsCheck) String 

func (ro *SchemaPartitionTableCountsCheck) String() string

type SchemaPartitionTypeCompatibles 

type SchemaPartitionTypeCompatibles struct {
	Schema        string `json:"schema"`
	PartitionType string `json:"partition_type"`
	ObjectCounts  string `json:"object_counts"`
	IsCompatible  string `json:"is_compatible"`
	IsConvertible string `json:"is_convertible"`
}

func (*SchemaPartitionTypeCompatibles) String 

func (sc *SchemaPartitionTypeCompatibles) String() string

type SchemaSequenceNameLengthCheck 

type SchemaSequenceNameLengthCheck struct {
	Schema       string `json:"schema"`
	SequenceName string `json:"sequence_name"`
	OrderFlag    string `json:"order_flag"`
	Length       string `json:"length"`
}

func (*SchemaSequenceNameLengthCheck) String 

func (ro *SchemaSequenceNameLengthCheck) String() string

type SchemaSubPartitionTypeCompatibles 

type SchemaSubPartitionTypeCompatibles struct {
	Schema           string `json:"schema"`
	SubPartitionType string `json:"sub_partition_type"`
	ObjectCounts     string `json:"object_counts"`
	IsCompatible     string `json:"is_compatible"`
	IsConvertible    string `json:"is_convertible"`
}

func (*SchemaSubPartitionTypeCompatibles) String 

func (sc *SchemaSubPartitionTypeCompatibles) String() string

type SchemaSynonymObject 

type SchemaSynonymObject struct {
	Schema      string `json:"schema"`
	SynonymName string `json:"synonym_name"`
	TableOwner  string `json:"table_owner"`
	TableName   string `json:"table_name"`
}

func (*SchemaSynonymObject) String 

func (ro *SchemaSynonymObject) String() string

type SchemaTableAvgRowLengthTOP 

type SchemaTableAvgRowLengthTOP struct {
	Schema       string `json:"schema"`
	TableName    string `json:"table_name"`
	AvgRowLength string `json:"avg_row_length"`
}

func (*SchemaTableAvgRowLengthTOP) String 

func (ro *SchemaTableAvgRowLengthTOP) String() string

type SchemaTableColumnCountsCheck 

type SchemaTableColumnCountsCheck struct {
	Schema       string `json:"schema"`
	TableName    string `json:"table_name"`
	ColumnCounts string `json:"column_counts"`
}

func (*SchemaTableColumnCountsCheck) String 

func (ro *SchemaTableColumnCountsCheck) String() string

type SchemaTableColumnNameLengthCheck 

type SchemaTableColumnNameLengthCheck struct {
	Schema     string `json:"schema"`
	TableName  string `json:"table_name"`
	ColumnName string `json:"column_name"`
	Length     string `json:"length"`
}

func (*SchemaTableColumnNameLengthCheck) String 

func (ro *SchemaTableColumnNameLengthCheck) String() string

type SchemaTableIndexCountsCheck 

type SchemaTableIndexCountsCheck struct {
	Schema      string `json:"schema"`
	TableName   string `json:"table_name"`
	IndexCounts string `json:"index_counts"`
}

func (*SchemaTableIndexCountsCheck) String 

func (ro *SchemaTableIndexCountsCheck) String() string

type SchemaTableIndexNameLengthCheck 

type SchemaTableIndexNameLengthCheck struct {
	Schema    string `json:"schema"`
	TableName string `json:"table_name"`
	IndexName string `json:"index_name"`
	Length    string `json:"length"`
}

func (*SchemaTableIndexNameLengthCheck) String 

func (ro *SchemaTableIndexNameLengthCheck) String() string

type SchemaTableIndexRowLengthCheck 

type SchemaTableIndexRowLengthCheck struct {
	Schema       string `json:"schema"`
	TableName    string `json:"table_name"`
	IndexName    string `json:"index_name"`
	ColumnLength string `json:"column_length"`
}

func (*SchemaTableIndexRowLengthCheck) String 

func (ro *SchemaTableIndexRowLengthCheck) String() string

type SchemaTableNameLengthCheck 

type SchemaTableNameLengthCheck struct {
	Schema    string `json:"schema"`
	TableName string `json:"table_name"`
	Length    string `json:"length"`
}

func (*SchemaTableNameLengthCheck) String 

func (ro *SchemaTableNameLengthCheck) String() string

type SchemaTableNumberTypeEqualZero 

type SchemaTableNumberTypeEqualZero struct {
	Schema        string `json:"schema"`
	TableName     string `json:"table_name"`
	ColumnName    string `json:"column_name"`
	DataPrecision string `json:"data_precision"`
	DataScale     string `json:"data_scale"`
}

func (*SchemaTableNumberTypeEqualZero) String 

func (ro *SchemaTableNumberTypeEqualZero) String() string

type SchemaTableRowLengthCheck 

type SchemaTableRowLengthCheck struct {
	Schema       string `json:"schema"`
	TableName    string `json:"table_name"`
	AvgRowLength string `json:"avg_row_length"`
}

func (*SchemaTableRowLengthCheck) String 

func (ro *SchemaTableRowLengthCheck) String() string

type SchemaTableRowsTOP 

type SchemaTableRowsTOP struct {
	Schema    string `json:"schema"`
	TableName string `json:"table_name"`
	TableType string `json:"table_type"`
	TableSize string `json:"table_size"`
}

func (*SchemaTableRowsTOP) String 

func (ro *SchemaTableRowsTOP) String() string

type SchemaTableSizeData 

type SchemaTableSizeData struct {
	Schema        string `json:"schema"`
	TableSize     string `json:"table_size"`
	IndexSize     string `json:"index_size"`
	LobTableSize  string `json:"lob_table_size"`
	LobIndexSize  string `json:"lob_index_size"`
	AllTablesRows string `json:"all_tables_rows"`
}

func (*SchemaTableSizeData) String 

func (ro *SchemaTableSizeData) String() string

type SchemaTableTypeCompatibles 

type SchemaTableTypeCompatibles struct {
	Schema        string `json:"schema"`
	TableType     string `json:"table_type"`
	ObjectCounts  string `json:"object_counts"`
	ObjectSize    string `json:"object_size"`
	IsCompatible  string `json:"is_compatible"`
	IsConvertible string `json:"is_convertible"`
}

func (*SchemaTableTypeCompatibles) String 

func (sc *SchemaTableTypeCompatibles) String() string

type SchemaTemporaryTableTypeCompatibles 

type SchemaTemporaryTableTypeCompatibles struct {
	Schema             string `json:"schema"`
	TemporaryTableType string `json:"temporary_table_type"`
	ObjectCounts       string `json:"object_counts"`
	IsCompatible       string `json:"is_compatible"`
	IsConvertible      string `json:"is_convertible"`
}

func (*SchemaTemporaryTableTypeCompatibles) String 

func (sc *SchemaTemporaryTableTypeCompatibles) String() string

type SchemaViewNameLengthCheck 

type SchemaViewNameLengthCheck struct {
	Schema   string `json:"schema"`
	ViewName string `json:"view_name"`
	ReadOnly string `json:"read_only"`
	Length   string `json:"length"`
}

func (*SchemaViewNameLengthCheck) String 

func (ro *SchemaViewNameLengthCheck) String() string

type SchemaViewTypeCompatibles 

type SchemaViewTypeCompatibles struct {
	Schema        string `json:"schema"`
	ViewType      string `json:"view_type"`
	ViewTypeOwner string `json:"view_type_owner"`
	ObjectCounts  string `json:"object_counts"`
	IsCompatible  string `json:"is_compatible"`
	IsConvertible string `json:"is_convertible"`
}

func (*SchemaViewTypeCompatibles) String 

func (sc *SchemaViewTypeCompatibles) String() string

type SqlMigrateTask 

type SqlMigrateTask struct {
	Ctx         context.Context
	Task        *task.Task
	DatasourceS *datasource.Datasource
	DatasourceT *datasource.Datasource
	TaskParams  *pb.SqlMigrateParam
}

func (*SqlMigrateTask) InitSqlMigrateTask 

func (smt *SqlMigrateTask) InitSqlMigrateTask(databaseS database.IDatabase) error

func (*SqlMigrateTask) Start 

func (smt *SqlMigrateTask) Start() error

type StmtMigrateTask 

type StmtMigrateTask struct {
	Ctx         context.Context
	Task        *task.Task
	DatasourceS *datasource.Datasource
	DatasourceT *datasource.Datasource
	TaskParams  *pb.StatementMigrateParam
}

func (*StmtMigrateTask) Start 

func (stm *StmtMigrateTask) Start() error

type StructCompareTask 

type StructCompareTask struct {
	Ctx         context.Context
	Task        *task.Task
	DatasourceS *datasource.Datasource
	DatasourceT *datasource.Datasource
	TaskParams  *pb.StructCompareParam
}

func (*StructCompareTask) Start 

func (dmt *StructCompareTask) Start() error

type StructMigrateTable 

type StructMigrateTable struct {
	TaskName            string                                `json:"taskName"`
	TaskFlow            string                                `json:"taskFlow"`
	DatasourceS         *processor.Datasource                 `json:"datasourceS"`
	TableAttributes     *database.StructMigrateAttributes     `json:"tableAttributes"`
	TableAttributesRule *database.StructMigrateAttributesRule `json:"tableAttributesRule"`
	DBCharsetT          string                                `json:"DBCharsetT"`
}

func (*StructMigrateTable) GenSchemaNameS 

func (t *StructMigrateTable) GenSchemaNameS() string

func (*StructMigrateTable) GenSchemaNameT 

func (t *StructMigrateTable) GenSchemaNameT() (string, error)

func (*StructMigrateTable) GenTableCheckKey 

func (t *StructMigrateTable) GenTableCheckKey() ([]string, error)

func (*StructMigrateTable) GenTableColumnComment 

func (t *StructMigrateTable) GenTableColumnComment() ([]string, error)

func (*StructMigrateTable) GenTableColumns 

func (t *StructMigrateTable) GenTableColumns() ([]string, error)

func (*StructMigrateTable) GenTableComment 

func (t *StructMigrateTable) GenTableComment() (string, error)

func (*StructMigrateTable) GenTableCreatePrefixT 

func (t *StructMigrateTable) GenTableCreatePrefixT() string

func (*StructMigrateTable) GenTableForeignKey 

func (t *StructMigrateTable) GenTableForeignKey() ([]string, error)

func (*StructMigrateTable) GenTableNameS 

func (t *StructMigrateTable) GenTableNameS() string

func (*StructMigrateTable) GenTableNameT 

func (t *StructMigrateTable) GenTableNameT() (string, error)

func (*StructMigrateTable) GenTableNormalIndex 

func (t *StructMigrateTable) GenTableNormalIndex() ([]string, []string, error)

func (*StructMigrateTable) GenTableOriginDDlS 

func (t *StructMigrateTable) GenTableOriginDDlS() string

func (*StructMigrateTable) GenTablePrimaryKey 

func (t *StructMigrateTable) GenTablePrimaryKey() (string, error)

func (*StructMigrateTable) GenTableSuffix 

func (t *StructMigrateTable) GenTableSuffix() (string, error)

func (*StructMigrateTable) GenTableTypeS 

func (t *StructMigrateTable) GenTableTypeS() string

func (*StructMigrateTable) GenTableUniqueIndex 

func (t *StructMigrateTable) GenTableUniqueIndex() ([]string, []string, error)

func (*StructMigrateTable) GenTableUniqueKey 

func (t *StructMigrateTable) GenTableUniqueKey() ([]string, error)

func (*StructMigrateTable) String 

func (t *StructMigrateTable) String() string

type StructMigrateTask 

type StructMigrateTask struct {
	Ctx         context.Context
	Task        *task.Task
	SchemaNameS string
	SchemaNameT string
	DatabaseS   database.IDatabase
	DatabaseT   database.IDatabase
	DBCharsetS  string
	DBCharsetT  string
	TaskParams  *pb.StructMigrateParam
}

func (*StructMigrateTask) Start 

func (st *StructMigrateTask) Start() error

type UsernameLengthCheck 

type UsernameLengthCheck struct {
	Schema        string `json:"schema"`
	AccountStatus string `json:"account_status"`
	Created       string `json:"created"`
	Length        string `json:"length"`
}

func (*UsernameLengthCheck) String 

func (ro *UsernameLengthCheck) String() string

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.