func checkPrimaryKeyPrefix()

in webv2/api/schema.go [1322:1430]
94 lines of code
32 McCabe index (conditional complexity)

func checkPrimaryKeyPrefix(tableId string, refTableId string, fk ddl.Foreignkey, tableInterleaveStatus *types.TableInterleaveStatus) bool {
	sessionState := session.GetSessionState()
	childTable := sessionState.Conv.SpSchema[tableId]
	parentTable := sessionState.Conv.SpSchema[refTableId]
	childPks := sessionState.Conv.SpSchema[tableId].PrimaryKeys
	parentPks := sessionState.Conv.SpSchema[refTableId].PrimaryKeys
	possibleInterleave := false

	flag := false
	for _, key := range parentPks {
		flag = false
		for _, colId := range fk.ReferColumnIds {
			if key.ColId == colId {
				flag = true
			}
		}
		if !flag {
			break
		}
	}
	if flag {
		possibleInterleave = true
	}

	if !possibleInterleave {
		removeInterleaveSuggestions(fk.ColIds, tableId)
		return false
	}

	childPkColIds := []string{}
	for _, k := range childPks {
		childPkColIds = append(childPkColIds, k.ColId)
	}

	interleaved := []ddl.IndexKey{}

	for i := 0; i < len(parentPks); i++ {
		for j := 0; j < len(childPks); j++ {
			for k := 0; k < len(fk.ReferColumnIds); k++ {
				if childTable.ColDefs[fk.ColIds[k]].Name == parentTable.ColDefs[fk.ReferColumnIds[k]].Name &&
					parentTable.ColDefs[parentPks[i].ColId].Name == childTable.ColDefs[childPks[j].ColId].Name &&
					parentTable.ColDefs[parentPks[i].ColId].T.Name == childTable.ColDefs[childPks[j].ColId].T.Name &&
					parentTable.ColDefs[parentPks[i].ColId].T.Len == childTable.ColDefs[childPks[j].ColId].T.Len &&
					parentTable.ColDefs[parentPks[i].ColId].Name == parentTable.ColDefs[fk.ReferColumnIds[k]].Name &&
					childTable.ColDefs[childPks[j].ColId].Name == parentTable.ColDefs[fk.ReferColumnIds[k]].Name {

					interleaved = append(interleaved, parentPks[i])
				}
			}
		}
	}

	if len(interleaved) == len(parentPks) {
		return true
	}

	diff := []ddl.IndexKey{}

	if len(interleaved) == 0 {
		for i := 0; i < len(parentPks); i++ {
			for j := 0; j < len(childPks); j++ {
				if parentTable.ColDefs[parentPks[i].ColId].Name != childTable.ColDefs[childPks[j].ColId].Name || parentTable.ColDefs[parentPks[i].ColId].T.Len != childTable.ColDefs[childPks[j].ColId].T.Len {
					diff = append(diff, parentPks[i])
				}
			}
		}
	}

	canInterleavedOnAdd := []string{}
	canInterleavedOnRename := []string{}
	canInterLeaveOnChangeInColumnSize := []string{}

	fkReferColNames := []string{}
	childPkColNames := []string{}
	for _, colId := range fk.ReferColumnIds {
		fkReferColNames = append(fkReferColNames, parentTable.ColDefs[colId].Name)
	}
	for _, colId := range childPkColIds {
		childPkColNames = append(childPkColNames, childTable.ColDefs[colId].Name)
	}

	for i := 0; i < len(diff); i++ {

		parentColIndex := utilities.IsColumnPresent(fkReferColNames, parentTable.ColDefs[diff[i].ColId].Name)
		if parentColIndex == -1 {
			continue
		}
		childColIndex := utilities.IsColumnPresent(childPkColNames, childTable.ColDefs[fk.ColIds[parentColIndex]].Name)
		if childColIndex == -1 {
			canInterleavedOnAdd = append(canInterleavedOnAdd, fk.ColIds[parentColIndex])
		} else {
			if parentTable.ColDefs[diff[i].ColId].Name == childTable.ColDefs[fk.ColIds[parentColIndex]].Name {
				canInterLeaveOnChangeInColumnSize = append(canInterLeaveOnChangeInColumnSize, fk.ColIds[parentColIndex])
			} else {
				canInterleavedOnRename = append(canInterleavedOnRename, fk.ColIds[parentColIndex])
			}
		}
	}

	if len(canInterLeaveOnChangeInColumnSize) > 0 {
		updateInterleaveSuggestion(canInterLeaveOnChangeInColumnSize, tableId, internal.InterleavedChangeColumnSize)
	} else if len(canInterleavedOnRename) > 0 {
		updateInterleaveSuggestion(canInterleavedOnRename, tableId, internal.InterleavedRenameColumn)
	} else if len(canInterleavedOnAdd) > 0 {
		updateInterleaveSuggestion(canInterleavedOnAdd, tableId, internal.InterleavedAddColumn)
	}

	return false
}