github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/libraries/go-xorm/builder/builder.go (about)

     1  package builder
     2  
     3  type optype byte
     4  
     5  const (
     6  	condType   optype = iota // only conditions
     7  	selectType               // select
     8  	insertType               // insert
     9  	updateType               // update
    10  	deleteType               // delete
    11  )
    12  
    13  type join struct {
    14  	joinType  string
    15  	joinTable string
    16  	joinCond  Cond
    17  }
    18  
    19  type Builder struct {
    20  	optype
    21  	tableName string
    22  	cond      Cond
    23  	selects   []string
    24  	joins     []join
    25  	inserts   Eq
    26  	updates   []Eq
    27  }
    28  
    29  func Select(cols ...string) *Builder {
    30  	builder := &Builder{cond: NewCond()}
    31  	return builder.Select(cols...)
    32  }
    33  
    34  func Insert(eq Eq) *Builder {
    35  	builder := &Builder{cond: NewCond()}
    36  	return builder.Insert(eq)
    37  }
    38  
    39  func Update(updates ...Eq) *Builder {
    40  	builder := &Builder{cond: NewCond()}
    41  	return builder.Update(updates...)
    42  }
    43  
    44  func Delete(conds ...Cond) *Builder {
    45  	builder := &Builder{cond: NewCond()}
    46  	return builder.Delete(conds...)
    47  }
    48  
    49  func (b *Builder) Where(cond Cond) *Builder {
    50  	b.cond = b.cond.And(cond)
    51  	return b
    52  }
    53  
    54  func (b *Builder) From(tableName string) *Builder {
    55  	b.tableName = tableName
    56  	return b
    57  }
    58  
    59  func (b *Builder) Into(tableName string) *Builder {
    60  	b.tableName = tableName
    61  	return b
    62  }
    63  
    64  func (b *Builder) Join(joinType, joinTable string, joinCond interface{}) *Builder {
    65  	switch joinCond.(type) {
    66  	case Cond:
    67  		b.joins = append(b.joins, join{joinType, joinTable, joinCond.(Cond)})
    68  	case string:
    69  		b.joins = append(b.joins, join{joinType, joinTable, Expr(joinCond.(string))})
    70  	}
    71  
    72  	return b
    73  }
    74  
    75  func (b *Builder) InnerJoin(joinTable string, joinCond interface{}) *Builder {
    76  	return b.Join("INNER", joinTable, joinCond)
    77  }
    78  
    79  func (b *Builder) LeftJoin(joinTable string, joinCond interface{}) *Builder {
    80  	return b.Join("LEFT", joinTable, joinCond)
    81  }
    82  
    83  func (b *Builder) RightJoin(joinTable string, joinCond interface{}) *Builder {
    84  	return b.Join("RIGHT", joinTable, joinCond)
    85  }
    86  
    87  func (b *Builder) CrossJoin(joinTable string, joinCond interface{}) *Builder {
    88  	return b.Join("CROSS", joinTable, joinCond)
    89  }
    90  
    91  func (b *Builder) FullJoin(joinTable string, joinCond interface{}) *Builder {
    92  	return b.Join("FULL", joinTable, joinCond)
    93  }
    94  
    95  func (b *Builder) Select(cols ...string) *Builder {
    96  	b.selects = cols
    97  	b.optype = selectType
    98  	return b
    99  }
   100  
   101  func (b *Builder) And(cond Cond) *Builder {
   102  	b.cond = And(b.cond, cond)
   103  	return b
   104  }
   105  
   106  func (b *Builder) Or(cond Cond) *Builder {
   107  	b.cond = Or(b.cond, cond)
   108  	return b
   109  }
   110  
   111  func (b *Builder) Insert(eq Eq) *Builder {
   112  	b.inserts = eq
   113  	b.optype = insertType
   114  	return b
   115  }
   116  
   117  func (b *Builder) Update(updates ...Eq) *Builder {
   118  	b.updates = updates
   119  	b.optype = updateType
   120  	return b
   121  }
   122  
   123  func (b *Builder) Delete(conds ...Cond) *Builder {
   124  	b.cond = b.cond.And(conds...)
   125  	b.optype = deleteType
   126  	return b
   127  }
   128  
   129  func (b *Builder) WriteTo(w Writer) error {
   130  	switch b.optype {
   131  	case condType:
   132  		return b.cond.WriteTo(w)
   133  	case selectType:
   134  		return b.selectWriteTo(w)
   135  	case insertType:
   136  		return b.insertWriteTo(w)
   137  	case updateType:
   138  		return b.updateWriteTo(w)
   139  	case deleteType:
   140  		return b.deleteWriteTo(w)
   141  	}
   142  
   143  	return ErrNotSupportType
   144  }
   145  
   146  // ToSQL convert a builder to SQL and args
   147  func (b *Builder) ToSQL() (string, []interface{}, error) {
   148  	w := NewWriter()
   149  	if err := b.WriteTo(w); err != nil {
   150  		return "", nil, err
   151  	}
   152  
   153  	return w.writer.String(), w.args, nil
   154  }
   155  
   156  // ToSQL convert a builder or condtions to SQL and args
   157  func ToSQL(cond interface{}) (string, []interface{}, error) {
   158  	switch cond.(type) {
   159  	case Cond:
   160  		return condToSQL(cond.(Cond))
   161  	case *Builder:
   162  		return cond.(*Builder).ToSQL()
   163  	}
   164  	return "", nil, ErrNotSupportType
   165  }