func (dd *DeleteDataset) Where(expressions ...exp.Expression) *DeleteDataset {
	return dd.copy(dd.clauses.WhereAppend(expressions...))
}
Adds a WHERE clause. See examples.
package goqu
import (
	"github.com/doug-martin/goqu/v9/exec"
	"github.com/doug-martin/goqu/v9/exp"
	"github.com/doug-martin/goqu/v9/internal/errors"
	"github.com/doug-martin/goqu/v9/internal/sb"
)
var ErrBadFromArgument = errors.New("unsupported DeleteDataset#From argument, a string or identifier expression is required")
type DeleteDataset struct {
	dialect      SQLDialect
	clauses      exp.DeleteClauses
	isPrepared   prepared
	queryFactory exec.QueryFactory
	err          error
}
func newDeleteDataset(d string, queryFactory exec.QueryFactory) *DeleteDataset {
	return &DeleteDataset{
		clauses:      exp.NewDeleteClauses(),
		dialect:      GetDialect(d),
		queryFactory: queryFactory,
		isPrepared:   preparedNoPreference,
		err:          nil,
	}
}
func Delete(table interface{}) *DeleteDataset {
	return newDeleteDataset("default", nil).From(table)
}
func (dd *DeleteDataset) Expression() exp.Expression {
	return dd
}
func (dd *DeleteDataset) Clone() exp.Expression {
	return dd.copy(dd.clauses)
}
func (dd *DeleteDataset) Prepared(prepared bool) *DeleteDataset {
	ret := dd.copy(dd.clauses)
	ret.isPrepared = preparedFromBool(prepared)
	return ret
}
func (dd *DeleteDataset) IsPrepared() bool {
	return dd.isPrepared.Bool()
}
func (dd *DeleteDataset) WithDialect(dl string) *DeleteDataset {
	ds := dd.copy(dd.GetClauses())
	ds.dialect = GetDialect(dl)
	return ds
}
func (dd *DeleteDataset) Dialect() SQLDialect {
	return dd.dialect
}
func (dd *DeleteDataset) SetDialect(dialect SQLDialect) *DeleteDataset {
	cd := dd.copy(dd.GetClauses())
	cd.dialect = dialect
	return cd
}
func (dd *DeleteDataset) GetClauses() exp.DeleteClauses {
	return dd.clauses
}
func (dd *DeleteDataset) copy(clauses exp.DeleteClauses) *DeleteDataset {
	return &DeleteDataset{
		dialect:      dd.dialect,
		clauses:      clauses,
		isPrepared:   dd.isPrepared,
		queryFactory: dd.queryFactory,
		err:          dd.err,
	}
}
func (dd *DeleteDataset) With(name string, subquery exp.Expression) *DeleteDataset {
	return dd.copy(dd.clauses.CommonTablesAppend(exp.NewCommonTableExpression(false, name, subquery)))
}
func (dd *DeleteDataset) WithRecursive(name string, subquery exp.Expression) *DeleteDataset {
	return dd.copy(dd.clauses.CommonTablesAppend(exp.NewCommonTableExpression(true, name, subquery)))
}
func (dd *DeleteDataset) From(table interface{}) *DeleteDataset {
	switch t := table.(type) {
	case exp.IdentifierExpression:
		return dd.copy(dd.clauses.SetFrom(t))
	case string:
		return dd.copy(dd.clauses.SetFrom(exp.ParseIdentifier(t)))
	default:
		panic(ErrBadFromArgument)
	}
}