</cliOption>
      </cliOptions>
    </expression>
    <expression>
      <syntax>reactorProjects</syntax>
      <description>This is the current list of projects being built by
        Maven.</description>
    </expression>
  </expressions>

	column := "column-name"
	results := []struct {
		Expressions  []clause.Expression
		ExpectedVars []interface{}
		Result       string
	}{{
		Expressions: []clause.Expression{
			clause.Eq{Column: column, Value: "column-value"},
		},
		ExpectedVars: []interface{}{"column-value"},
		Result:       "`column-name` = ?",
	}, {
		Expressions: []clause.Expression{
			clause.Eq{Column: column, Value: nil},

      NOTE: It's also possible to switch to offline mode on a per-build basis, using the '-o' command-line option.
    ]]></description>
    </expression>
    <expression>
      <syntax>settings.interactiveMode</syntax>
      <configuration>
        <![CDATA[
    <interactiveMode>true</interactiveMode>
    ]]></configuration>
      <description>
        <![CDATA[

		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrParseExpectedKeyword: {
		Code:           "ParseExpectedKeyword",
		Description:    "Did not find the expected keyword in the SQL expression.",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrParseExpectedTokenType: {
		Code:           "ParseExpectedTokenType",
		Description:    "Did not find the expected token in the SQL expression.",

type Clause struct {
	Name                string // WHERE
	BeforeExpression    Expression
	AfterNameExpression Expression
	AfterExpression     Expression
	Expression          Expression
	Builder             ClauseBuilder
}

// Build build clause
func (c Clause) Build(builder Builder) {
	if c.Builder != nil {
		c.Builder(c, builder)
	} else if c.Expression != nil {
		if c.BeforeExpression != nil {
			c.BeforeExpression.Build(builder)

        }
    }

    /**
     * Adds a client with a regular expression pattern.
     * @param regex The regular expression to match URLs.
     * @param client The CrawlerClient instance.
     */
    public void addClient(final String regex, final CrawlerClient client) {
        if (StringUtil.isBlank(regex)) {
            throw new CrawlerSystemException("A regular expression is null.");
        }
        if (client == null) {

  @JvmName("-deprecated_url")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "url"),
    level = DeprecationLevel.ERROR,
  )
  fun url(): HttpUrl = url

  @JvmName("-deprecated_dns")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "dns"),
    level = DeprecationLevel.ERROR,
  )
  fun dns(): Dns = dns

type Join struct {
	Type       JoinType
	Table      Table
	ON         Where
	Using      []string
	Expression Expression
}

func JoinTable(names ...string) Table {
	return Table{
		Name: utils.JoinNestedRelationNames(names),
	}
}

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

			},
			sql: "INNER JOIN `user` USING (`id`)",
		},
		{
			name: "Expression",
			join: clause.Join{
				// Invalid
				Type:  clause.LeftJoin,
				Table: clause.Table{Name: "user"},
				ON: clause.Where{
					Exprs: []clause.Expression{clause.Eq{clause.Column{Table: "user_info", Name: "user_id"}, clause.PrimaryColumn}},
				},
				// Valid
				Expression: clause.Join{
					Type:  clause.InnerJoin,

				Exprs: []clause.Expression{clause.Or(clause.Neq{Column: "name", Value: "jinzhu"}), clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}},
			}},
			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ? AND `age` > ?",
			[]interface{}{"1", "jinzhu", 18},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{