tx.Statement.TableExpr = &clause.Expr{SQL: name, Vars: args}
		if results := tableRegexp.FindStringSubmatch(name); len(results) == 3 {
			if results[1] != "" {
				tx.Statement.Table = results[1]
			} else {
				tx.Statement.Table = results[2]
			}
		}
	} else if tables := strings.Split(name, "."); len(tables) == 2 {
		tx.Statement.TableExpr = &clause.Expr{SQL: tx.Statement.Quote(name)}
		tx.Statement.Table = tables[1]

				tx.Clauses(clause.Expr{SQL: strings.Replace(joinStmt.SQL.String(), "WHERE ", "", 1), Vars: joinStmt.Vars})
			}
		}

		tx = tx.Session(&Session{QueryFields: true}).Clauses(clause.From{Joins: []clause.Join{{
			Table: clause.Table{Name: association.Relationship.JoinTable.Table},
			ON:    clause.Where{Exprs: queryConds},
		}}})
	} else {
		tx.Clauses(clause.Where{Exprs: queryConds})
	}

	return tx
}

	for idx, column := range groupBy.Columns {
		if idx > 0 {
			builder.WriteByte(',')
		}

		builder.WriteQuoted(column)
	}

	if len(groupBy.Having) > 0 {
		builder.WriteString(" HAVING ")
		Where{Exprs: groupBy.Having}.Build(builder)
	}
}

// MergeClause merge group by clause
func (groupBy GroupBy) MergeClause(clause *Clause) {
	if v, ok := clause.Expression.(GroupBy); ok {

					j.Omits = stmt.Omits
				}
			}

			expr := clause.NamedExpr{SQL: fmt.Sprintf("%s JOIN (?) AS ?", joinType), Vars: []interface{}{jt.Subquery, clause.Table{Name: j.Alias}}}

			if j.On != nil {
				expr.SQL += " ON ?"
				expr.Vars = append(expr.Vars, clause.AndConditions{Exprs: j.On.Exprs})
			}

			j.Expression = expr
		}

		db.Statement.Joins = append(db.Statement.Joins, j)

				Exprs: []clause.Expression{clause.Not(clause.Expr{SQL: "`score` <= ?", Vars: []interface{}{100}},
					clause.Expr{SQL: "`age` <= ?", Vars: []interface{}{60}})},
			}},
			"SELECT * FROM `users` WHERE NOT (`score` <= ? AND `age` <= ?)",
			[]interface{}{100, 60},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{
				Exprs: []clause.Expression{

		}

		if len(onConflict.TargetWhere.Exprs) > 0 {
			builder.WriteString(" WHERE ")
			onConflict.TargetWhere.Build(builder)
			builder.WriteByte(' ')
		}
	}

	if onConflict.DoNothing {
		builder.WriteString("DO NOTHING")
	} else {
		builder.WriteString("DO UPDATE SET ")
		onConflict.DoUpdates.Build(builder)
	}

	if len(onConflict.Where.Exprs) > 0 {
		builder.WriteString(" WHERE ")

	newDB.Clauses(
		clause.From{
			Tables: []clause.Table{{Name: "users"}},
			Joins: []clause.Join{
				{
					Table: clause.Table{Name: "companies", Raw: false},
					ON: clause.Where{
						Exprs: []clause.Expression{
							clause.Eq{
								Column: clause.Column{
									Table: "users",
									Name:  "company_id",
								},
								Value: clause.Column{
									Table: "companies",

		t.Fatalf("Build OR condition, but got %v", result.Statement.SQL.String())
	}

	sub := dryDB.Clauses(clause.Where{
		Exprs: []clause.Expression{
			clause.OrConditions{
				Exprs: []clause.Expression{
					clause.Expr{SQL: "role = ?", Vars: []interface{}{"super_admin"}},
					clause.Expr{SQL: "role = ?", Vars: []interface{}{"admin"}},
				},
			},
		},
	})
	result = dryDB.Where(sub).Find(&User{})

					},
				},
			}, clause.From{}},
			"SELECT `id`, `name`, LENGTH(`mobile`) FROM `users`", nil,
		},
		{
			[]clause.Interface{clause.Select{
				Expression: clause.CommaExpression{
					Exprs: []clause.Expression{
						clause.Expr{
							SQL: "? as name",
							Vars: []interface{}{
								clause.Eq{
									Column: clause.Column{Name: "age"},
									Value:  18,
								},
							},
						},
					},
				},

				if where, ok := cs.Expression.(clause.Where); ok {
					if len(where.Exprs) == 1 {
						if orConds, ok := where.Exprs[0].(clause.OrConditions); ok {
							if len(orConds.Exprs) == 1 {
								where.Exprs[0] = clause.AndConditions(orConds)
							}
						}
					}
					conds = append(conds, clause.And(where.Exprs...))
				} else if cs.Expression != nil {
					conds = append(conds, cs.Expression)
				}