Method joinTables

engine/engine.go:550–605

(joinCommand *ast.JoinCommand, leftTableName string)

}

func (engine *DbEngine) joinTables(joinCommand *ast.JoinCommand, leftTableName string) (*Table, error) {
	leftTable, exist := engine.Tables[leftTableName]
	leftTablePrefix := leftTableName + "."
	if !exist {
		return nil, &TableDoesNotExistError{leftTableName}
	}

	rightTableName := joinCommand.Name.Token.Literal
	rightTablePrefix := rightTableName + "."
	rightTable, exist := engine.Tables[rightTableName]
	if !exist {
		return nil, &TableDoesNotExistError{rightTableName}
	}

	joinedTable := &Table{Columns: []*Column{}}

	addColumnsWithPrefix(joinedTable, leftTable.Columns, leftTablePrefix)
	addColumnsWithPrefix(joinedTable, rightTable.Columns, rightTablePrefix)

	leftTableWithAddedPrefix := leftTable.getTableCopyWithAddedPrefixToColumnNames(leftTablePrefix)
	rightTableWithAddedPrefix := rightTable.getTableCopyWithAddedPrefixToColumnNames(rightTablePrefix)
	var unmatchedRightRows = make(map[int]bool)

	for leftRowIndex := 0; leftRowIndex < len(leftTable.Columns[0].Values); leftRowIndex++ {
		joinedRowLeft := getRow(leftTableWithAddedPrefix, leftRowIndex)
		leftRowMatches := false

		for rightRowIndex := 0; rightRowIndex < len(rightTable.Columns[0].Values); rightRowIndex++ {
			joinedRowRight := getRow(rightTableWithAddedPrefix, rightRowIndex)
			maps.Copy(joinedRowRight, joinedRowLeft)

			fulfilledFilters, err := isFulfillingFilters(joinedRowRight, joinCommand.Expression, joinCommand.Token.Literal)
			if err != nil {
				return nil, err
			}

			isLastLeftRow := leftRowIndex == len(leftTable.Columns[0].Values)-1

			if fulfilledFilters {
				for colIndex, column := range joinedTable.Columns {
					joinedTable.Columns[colIndex].Values = append(joinedTable.Columns[colIndex].Values, joinedRowRight[column.Name])
				}
				leftRowMatches, unmatchedRightRows[rightRowIndex] = true, true
			} else if isLastLeftRow && joinCommand.ShouldTakeRightSide() && !unmatchedRightRows[rightRowIndex] {
				joinedRowRight = getRow(rightTableWithAddedPrefix, rightRowIndex)
				aggregateRowIntoJoinTable(leftTableWithAddedPrefix, joinedRowRight, joinedTable)
			}
		}

		if joinCommand.ShouldTakeLeftSide() && !leftRowMatches {
			aggregateRowIntoJoinTable(rightTableWithAddedPrefix, joinedRowLeft, joinedTable)
		}
	}

	return joinedTable, nil
}

func aggregateRowIntoJoinTable(tableWithAddedPrefix *Table, joinedRow map[string]ValueInterface, joinedTable *Table) {