// Package clause provides the clause interface and common clause implementations for GORM.
package clause

// Interface clause interface
type Interface interface {
	Name() string
	Build(Builder)
	MergeClause(*Clause)
}

// ClauseBuilder clause builder, allows to customize how to build clause
type ClauseBuilder func(Clause, Builder)

type Writer interface {
	WriteByte(byte) error
	WriteString(string) (int, error)
}

	}
}

// MergeClause merge order by clauses
func (returning Returning) MergeClause(clause *Clause) {
	if v, ok := clause.Expression.(Returning); ok && len(returning.Columns) > 0 {
		if v.Columns != nil {
			returning.Columns = append(v.Columns, returning.Columns...)
		} else {
			returning.Columns = nil
		}
	}
	clause.Expression = returning

#*    *##elseif ( $license.name == "BSD-2-Clause" || $license.name == "The BSD 2-Clause License"
                    || $license.url.contains( "www.opensource.org/licenses/bsd-license" ) )
#*      *##set ( $spdx = 'BSD-2-Clause' )
#*    *##elseif ( $license.name == "BSD-3-Clause"
                    || $license.url.contains( "opensource.org/licenses/BSD-3-Clause" ) )
#*      *##set ( $spdx = 'BSD-3-Clause' )

	tx = tx.Where("age = ?", 20)
	c, ok := tx.Statement.Clauses["WHERE"]
	if !ok {
		t.Fatalf("WHERE clause expected")
	}
	if where, ok := c.Expression.(clause.Where); !ok || len(where.Exprs) == 0 {
		t.Fatalf("WHERE expressions expected, got %v", c.Expression)
	}

	// Order
	tx = tx.Order("name DESC")
	if _, ok := tx.Statement.Clauses["ORDER BY"]; !ok {
		t.Fatalf("ORDER BY clause expected")
	}

	// Limit / Offset

		return stmt, err
	}

	// Analyze where clause
	if selectAST.Where != nil {
		whereQProp := selectAST.Where.analyze(&selectAST)
		if whereQProp.err != nil {
			err = errQueryAnalysisFailure(fmt.Errorf("Where clause error: %w", whereQProp.err))
			return stmt, err
		}

		if whereQProp.isAggregation {
			err = errQueryAnalysisFailure(errors.New("WHERE clause cannot have an aggregation"))
			return stmt, err
		}
	}

		builder.WriteByte('=')
		builder.WriteQuoted(Column{Name: PrimaryKey})
	}
}

// MergeClause merge assignments clauses
func (set Set) MergeClause(clause *Clause) {
	copiedAssignments := make([]Assignment, len(set))
	copy(copiedAssignments, set)
	clause.Expression = Set(copiedAssignments)
}

// Assignments implements Assigner for Set.
func (set Set) Assignments() []Assignment { return []Assignment(set) }

//	}})
func (db *DB) Order(value interface{}) (tx *DB) {
	tx = db.getInstance()

	switch v := value.(type) {
	case clause.OrderBy:
		tx.Statement.AddClause(v)
	case clause.OrderByColumn:
		tx.Statement.AddClause(clause.OrderBy{
			Columns: []clause.OrderByColumn{v},
		})
	case string:
		if v != "" {
			tx.Statement.AddClause(clause.OrderBy{
				Columns: []clause.OrderByColumn{{

            "Apache 2.0",
            "Apache 2",
            "ASL, version 2",
        ),
    ),
    BSD3(
        "3-Clause BSD License",
        "https://opensource.org/licenses/BSD-3-Clause",
        listOf(
            "BSD 3-Clause License",
            "BSD-3-Clause",
            "New BSD License",
            "The New BSD License",
            "BSD",
            "Revised BSD",

    }

    // Test convertBooleanQuery with MUST_NOT clause
    @Test
    public void test_convertBooleanQuery_withMustNotClause() {
        BooleanQuery.Builder boolQueryBuilder = new BooleanQuery.Builder();
        TermQuery termQuery = new TermQuery(new Term("field", "value"));
        boolQueryBuilder.add(termQuery, BooleanClause.Occur.MUST_NOT);
        // Add a MUST clause to make the query valid

				[]clause.Column{clause.PrimaryColumn},
			}, clause.Returning{
				[]clause.Column{{Name: "name"}, {Name: "age"}},
			}},
			"SELECT * FROM `users` RETURNING `users`.`id`,`name`,`age`", nil,
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Returning{
				[]clause.Column{clause.PrimaryColumn},
			}, clause.Returning{}, clause.Returning{
				[]clause.Column{{Name: "name"}, {Name: "age"}},
			}},