truncate_dataset.go

Documentation: github.com/doug-martin/goqu/v9

     1  package goqu
     2  
     3  import (
     4  	"github.com/doug-martin/goqu/v9/exec"
     5  	"github.com/doug-martin/goqu/v9/exp"
     6  	"github.com/doug-martin/goqu/v9/internal/sb"
     7  )
     8  
     9  type TruncateDataset struct {
    10  	dialect      SQLDialect
    11  	clauses      exp.TruncateClauses
    12  	isPrepared   prepared
    13  	queryFactory exec.QueryFactory
    14  	err          error
    15  }
    16  
    17  // used internally by database to create a database with a specific adapter
    18  func newTruncateDataset(d string, queryFactory exec.QueryFactory) *TruncateDataset {
    19  	return &TruncateDataset{
    20  		clauses:      exp.NewTruncateClauses(),
    21  		dialect:      GetDialect(d),
    22  		queryFactory: queryFactory,
    23  	}
    24  }
    25  
    26  func Truncate(table ...interface{}) *TruncateDataset {
    27  	return newTruncateDataset("default", nil).Table(table...)
    28  }
    29  
    30  // Sets the adapter used to serialize values and create the SQL statement
    31  func (td *TruncateDataset) WithDialect(dl string) *TruncateDataset {
    32  	ds := td.copy(td.GetClauses())
    33  	ds.dialect = GetDialect(dl)
    34  	return ds
    35  }
    36  
    37  // Set the parameter interpolation behavior. See examples
    38  //
    39  // prepared: If true the dataset WILL NOT interpolate the parameters.
    40  func (td *TruncateDataset) Prepared(prepared bool) *TruncateDataset {
    41  	ret := td.copy(td.clauses)
    42  	ret.isPrepared = preparedFromBool(prepared)
    43  	return ret
    44  }
    45  
    46  func (td *TruncateDataset) IsPrepared() bool {
    47  	return td.isPrepared.Bool()
    48  }
    49  
    50  // Returns the current adapter on the dataset
    51  func (td *TruncateDataset) Dialect() SQLDialect {
    52  	return td.dialect
    53  }
    54  
    55  // Returns the current adapter on the dataset
    56  func (td *TruncateDataset) SetDialect(dialect SQLDialect) *TruncateDataset {
    57  	cd := td.copy(td.GetClauses())
    58  	cd.dialect = dialect
    59  	return cd
    60  }
    61  
    62  func (td *TruncateDataset) Expression() exp.Expression {
    63  	return td
    64  }
    65  
    66  // Clones the dataset
    67  func (td *TruncateDataset) Clone() exp.Expression {
    68  	return td.copy(td.clauses)
    69  }
    70  
    71  // Returns the current clauses on the dataset.
    72  func (td *TruncateDataset) GetClauses() exp.TruncateClauses {
    73  	return td.clauses
    74  }
    75  
    76  // used interally to copy the dataset
    77  func (td *TruncateDataset) copy(clauses exp.TruncateClauses) *TruncateDataset {
    78  	return &TruncateDataset{
    79  		dialect:      td.dialect,
    80  		clauses:      clauses,
    81  		isPrepared:   td.isPrepared,
    82  		queryFactory: td.queryFactory,
    83  		err:          td.err,
    84  	}
    85  }
    86  
    87  // Adds a FROM clause. This return a new dataset with the original sources replaced. See examples.
    88  // You can pass in the following.
    89  //   string: Will automatically be turned into an identifier
    90  //   IdentifierExpression
    91  //   LiteralExpression: (See Literal) Will use the literal SQL
    92  func (td *TruncateDataset) Table(table ...interface{}) *TruncateDataset {
    93  	return td.copy(td.clauses.SetTable(exp.NewColumnListExpression(table...)))
    94  }
    95  
    96  // Adds a CASCADE clause
    97  func (td *TruncateDataset) Cascade() *TruncateDataset {
    98  	opts := td.clauses.Options()
    99  	opts.Cascade = true
   100  	return td.copy(td.clauses.SetOptions(opts))
   101  }
   102  
   103  // Clears the CASCADE clause
   104  func (td *TruncateDataset) NoCascade() *TruncateDataset {
   105  	opts := td.clauses.Options()
   106  	opts.Cascade = false
   107  	return td.copy(td.clauses.SetOptions(opts))
   108  }
   109  
   110  // Adds a RESTRICT clause
   111  func (td *TruncateDataset) Restrict() *TruncateDataset {
   112  	opts := td.clauses.Options()
   113  	opts.Restrict = true
   114  	return td.copy(td.clauses.SetOptions(opts))
   115  }
   116  
   117  // Clears the RESTRICT clause
   118  func (td *TruncateDataset) NoRestrict() *TruncateDataset {
   119  	opts := td.clauses.Options()
   120  	opts.Restrict = false
   121  	return td.copy(td.clauses.SetOptions(opts))
   122  }
   123  
   124  // Add a IDENTITY clause (e.g. RESTART)
   125  func (td *TruncateDataset) Identity(identity string) *TruncateDataset {
   126  	opts := td.clauses.Options()
   127  	opts.Identity = identity
   128  	return td.copy(td.clauses.SetOptions(opts))
   129  }
   130  
   131  // Get any error that has been set or nil if no error has been set.
   132  func (td *TruncateDataset) Error() error {
   133  	return td.err
   134  }
   135  
   136  // Set an error on the dataset if one has not already been set. This error will be returned by a future call to Error
   137  // or as part of ToSQL. This can be used by end users to record errors while building up queries without having to
   138  // track those separately.
   139  func (td *TruncateDataset) SetError(err error) *TruncateDataset {
   140  	if td.err == nil {
   141  		td.err = err
   142  	}
   143  
   144  	return td
   145  }
   146  
   147  // Generates a TRUNCATE sql statement, if Prepared has been called with true then the parameters will not be interpolated.
   148  // See examples.
   149  //
   150  // Errors:
   151  //  * There is an error generating the SQL
   152  func (td *TruncateDataset) ToSQL() (sql string, params []interface{}, err error) {
   153  	return td.truncateSQLBuilder().ToSQL()
   154  }
   155  
   156  // Generates the TRUNCATE sql, and returns an Exec struct with the sql set to the TRUNCATE statement
   157  //    db.From("test").Truncate().Executor().Exec()
   158  func (td *TruncateDataset) Executor() exec.QueryExecutor {
   159  	return td.queryFactory.FromSQLBuilder(td.truncateSQLBuilder())
   160  }
   161  
   162  func (td *TruncateDataset) truncateSQLBuilder() sb.SQLBuilder {
   163  	buf := sb.NewSQLBuilder(td.isPrepared.Bool())
   164  	if td.err != nil {
   165  		return buf.SetError(td.err)
   166  	}
   167  	td.dialect.ToTruncateSQL(buf, td.clauses)
   168  	return buf
   169  }
   170
View as plain text