func (j *InnerJoin) Resolved() bool {
	return j.left.Resolved() && j.right.Resolved() && j.Cond.Resolved()
}
Resolved implements the Resolvable interface.
package plan
import (
	"io"
	"os"
	"reflect"
	"strings"
	opentracing "github.com/opentracing/opentracing-go"
	"github.com/dolthub/go-mysql-server/sql"
)
const (
	inMemoryJoinKey        = "INMEMORY_JOINS"
	inMemoryJoinSessionVar = "inmemory_joins"
)
var useInMemoryJoins = shouldUseMemoryJoinsByEnv()
func shouldUseMemoryJoinsByEnv() bool {
	v := strings.TrimSpace(strings.ToLower(os.Getenv(inMemoryJoinKey)))
	return v == "on" || v == "1"
}
type JoinNode interface {
	sql.Node
	Left() sql.Node
	Right() sql.Node
	JoinCond() sql.Expression
	JoinType() JoinType
	Comment() string
	WithScopeLen(int) JoinNode
	WithMultipassMode() JoinNode
}
type joinStruct struct {
	BinaryNode
	Cond       sql.Expression
	CommentStr string
	ScopeLen   int
	JoinMode   joinMode
}
func (j joinStruct) Expressions() []sql.Expression {
	return []sql.Expression{j.Cond}
}
func (j joinStruct) JoinCond() sql.Expression {
	return j.Cond
}
func (j joinStruct) Comment() string {
	return j.CommentStr
}
type InnerJoin struct {
	joinStruct
}
var _ JoinNode = (*InnerJoin)(nil)
var _ sql.CommentedNode = (*InnerJoin)(nil)
func (j *InnerJoin) JoinType() JoinType {
	return JoinTypeInner
}
func NewInnerJoin(left, right sql.Node, cond sql.Expression) *InnerJoin {
	return &InnerJoin{
		joinStruct{
			BinaryNode: BinaryNode{
				left:  left,
				right: right,
			},
			Cond: cond,
		},
	}
}
func (j *InnerJoin) Schema() sql.Schema {
	return append(j.left.Schema(), j.right.Schema()...)
}