RightJoin JoinType = "RIGHT"
)

// Join clause for from
type Join struct {
	Type       JoinType
	Table      Table
	ON         Where
	Using      []string
	Expression Expression
}

func (join Join) Build(builder Builder) {
	if join.Expression != nil {
		join.Expression.Build(builder)
	} else {
		if join.Type != "" {
			builder.WriteString(string(join.Type))
			builder.WriteByte(' ')
		}

							}
						}
					} else {
						fromClause.Joins = append(fromClause.Joins, clause.Join{
							Expression: clause.NamedExpr{SQL: join.Name, Vars: join.Conds},
						})
					}
				} else {
					fromClause.Joins = append(fromClause.Joins, clause.Join{
						Expression: clause.NamedExpr{SQL: join.Name, Vars: join.Conds},
					})
				}
			}

			db.Statement.AddClause(fromClause)
		} else {

		Language
		Pet
	}

	results := make([]Result, 0, 1)
	DB.Select("users.*, user_speaks.*,  languages.*, pets.*").Table("users").Joins("JOIN user_speaks ON user_speaks.user_id = users.id").
		Joins("JOIN languages ON languages.code = user_speaks.language_code").
		Joins("LEFT OUTER JOIN pets ON pets.user_id = users.id").Find(&results)

	if len(results) == 0 {
		t.Fatalf("no record find")

					Joins: []clause.Join{
						{
							Type:  clause.RightJoin,
							Table: clause.Table{Name: "profiles"},
							ON: clause.Where{
								[]clause.Expression{clause.Eq{clause.Column{Table: "profiles", Name: "email"}, clause.Column{Table: clause.CurrentTable, Name: "email"}}},
							},
						},
					},
				}, clause.From{
					Joins: []clause.Join{
						{
							Type:  clause.InnerJoin,

			name: "RIGHT JOIN",
			join: clause.Join{
				Type:  clause.RightJoin,
				Table: clause.Table{Name: "user"},
				ON: clause.Where{
					Exprs: []clause.Expression{clause.Eq{clause.Column{Table: "user_info", Name: "user_id"}, clause.PrimaryColumn}},
				},
			},
			sql: "RIGHT JOIN `user` ON `user_info`.`user_id` = `users`.`id`",
		},
		{
			name: "INNER JOIN",
			join: clause.Join{
				Type:  clause.InnerJoin,

	value := Value{
		Name: "value",
		Nested: &Nested{
			Join: Join{
				Value: "j1",
				Preload: Preload{
					Value: "p1",
				},
			},
		},
	}

	if err := DB.Create(&value).Error; err != nil {
		t.Errorf("failed to create value, got err: %v", err)
	}

	var find1 Value

	}

	for _, join := range from.Joins {
		builder.WriteByte(' ')
		join.Build(builder)
	}
}

// MergeClause merge from clause
func (from From) MergeClause(clause *Clause) {
	clause.Expression = from

    assertEquals("", j.join(ImmutableMultimap.of().entries()));
    assertEquals("", j.join(ImmutableMultimap.of().entries().iterator()));
    assertEquals(":", j.join(ImmutableMultimap.of("", "").entries()));
    assertEquals(":", j.join(ImmutableMultimap.of("", "").entries().iterator()));
    assertEquals("1:a;1:b", j.join(ImmutableMultimap.of("1", "a", "1", "b").entries()));

	pkgpath = ""
	for _, element := range strings.Split(finalPkgpath, string(filepath.Separator)) {
		if debug {
			log.Printf("copying %s", pkgpath)
		}
		pkgpath = filepath.Join(pkgpath, element)
		dst := filepath.Join(dstbase, pkgpath)
		src := filepath.Join(cwd, pkgpath)
		if err := copyLocalDir(dst, src); err != nil {
			return "", err
		}
	}

	if underGoRoot {
		// Copy timezone file.
		//

                return StringUtils.join(newInputs, ",");
            }
            return StringUtils.join(newInputs, ",") + "=>" + StringUtils.join(newOutputs, ",");
        }
        if (Arrays.equals(inputs, outputs)) {
            return StringUtils.join(inputs, ",");
        }
        return StringUtils.join(inputs, ",") + "=>" + StringUtils.join(outputs, ",");
    }