/*
This method maps all the constituent clauses, namely the from,
let, where, group by and projection(select) within a Subselect
statement.
*/
func (this *Subselect) MapExpressions(mapper expression.Mapper) (err error) {
if this.from != nil {
err = this.from.MapExpressions(mapper)
if err != nil {
return
}
}
if this.let != nil {
err = this.let.MapExpressions(mapper)
if err != nil {
return
}
}
if this.where != nil {
this.where, err = mapper.Map(this.where)
if err != nil {
return
}
}
if this.group != nil {
err = this.group.MapExpressions(mapper)
if err != nil {
return
}
}
return this.projection.MapExpressions(mapper)
}
/*
Apply mapper to where condition expressions.
*/
func (this *MergeDelete) MapExpressions(mapper expression.Mapper) (err error) {
if this.where != nil {
this.where, err = mapper.Map(this.where)
}
return
}
/*
Applies mapper to all the expressions in the merge statement.
*/
func (this *Merge) MapExpressions(mapper expression.Mapper) (err error) {
err = this.source.MapExpressions(mapper)
if err != nil {
return
}
this.key, err = mapper.Map(this.key)
if err != nil {
return
}
err = this.actions.MapExpressions(mapper)
if err != nil {
return
}
if this.limit != nil {
this.limit, err = mapper.Map(this.limit)
if err != nil {
return
}
}
if this.returning != nil {
err = this.returning.MapExpressions(mapper)
}
return
}
/*
Applies mapper to all the expressions in the upsert statement.
*/
func (this *Upsert) MapExpressions(mapper expression.Mapper) (err error) {
if this.key != nil {
this.key, err = mapper.Map(this.key)
if err != nil {
return
}
}
if this.value != nil {
this.value, err = mapper.Map(this.value)
if err != nil {
return
}
}
if this.values != nil {
err = this.values.MapExpressions(mapper)
if err != nil {
return
}
}
if this.query != nil {
err = this.query.MapExpressions(mapper)
if err != nil {
return
}
}
if this.returning != nil {
err = this.returning.MapExpressions(mapper)
}
return
}
/*
Map the input expression of the result expr.
*/
func (this *ResultTerm) MapExpression(mapper expression.Mapper) (err error) {
if this.expr != nil {
this.expr, err = mapper.Map(this.expr)
}
return
}
/*
Applies mapper to the key and value expressions.
*/
func (this *Pair) MapExpressions(mapper expression.Mapper) (err error) {
this.Key, err = mapper.Map(this.Key)
if err != nil {
return
}
this.Value, err = mapper.Map(this.Value)
return
}
/*
Maps the source array of the unnest if the parent object(left)
is mapped successfully.
*/
func (this *Unnest) MapExpressions(mapper expression.Mapper) (err error) {
err = this.left.MapExpressions(mapper)
if err != nil {
return
}
this.expr, err = mapper.Map(this.expr)
return
}
/*
Map Expressions for all sort terms in the receiver.
*/
func (this SortTerms) MapExpressions(mapper expression.Mapper) (err error) {
for _, term := range this {
term.expr, err = mapper.Map(term.expr)
if err != nil {
return
}
}
return
}
/*
Applies mapper to the path expressions and update for in
the unset Term.
*/
func (this *UnsetTerm) MapExpressions(mapper expression.Mapper) (err error) {
path, err := mapper.Map(this.path)
if err != nil {
return err
}
this.path = path.(expression.Path)
if this.updateFor != nil {
err = this.updateFor.MapExpressions(mapper)
}
return
}
/*
Apply mapper to value and where expressions.
*/
func (this *MergeInsert) MapExpressions(mapper expression.Mapper) (err error) {
if this.value != nil {
this.value, err = mapper.Map(this.value)
if err != nil {
return
}
}
if this.where != nil {
this.where, err = mapper.Map(this.where)
}
return
}
/*
It is a utility function that takes in as input parameter
a mapper and maps the involved expressions to an expression.
If there is an error during the mapping, an error is returned.
*/
func (this *AggregateBase) MapChildren(mapper expression.Mapper) error {
children := this.Children()
for i, c := range children {
expr, err := mapper.Map(c)
if err != nil {
return err
}
children[i] = expr
}
return nil
}
/*
Apply mapper to expressions in the when clause and bindings.
*/
func (this *UpdateFor) MapExpressions(mapper expression.Mapper) (err error) {
err = this.bindings.MapExpressions(mapper)
if err != nil {
return
}
if this.when != nil {
this.when, err = mapper.Map(this.when)
if err != nil {
return
}
}
return
}
/*
This method maps all the constituent terms, namely projection and keys
in the from clause.
*/
func (this *KeyspaceTerm) MapExpressions(mapper expression.Mapper) (err error) {
if this.projection != nil {
expr, err := mapper.Map(this.projection)
if err != nil {
return err
}
this.projection = expr.(expression.Path)
}
if this.keys != nil {
this.keys, err = mapper.Map(this.keys)
if err != nil {
return err
}
}
return
}
/*
Applies mapper to the set, unset and where expressions.
*/
func (this *MergeUpdate) MapExpressions(mapper expression.Mapper) (err error) {
if this.set != nil {
err = this.set.MapExpressions(mapper)
if err != nil {
return
}
}
if this.unset != nil {
err = this.unset.MapExpressions(mapper)
if err != nil {
return
}
}
if this.where != nil {
this.where, err = mapper.Map(this.where)
}
return
}
/*
This method maps all the constituent clauses, namely the
by, letting and having within a group by clause.
*/
func (this *Group) MapExpressions(mapper expression.Mapper) (err error) {
if this.by != nil {
err = this.by.MapExpressions(mapper)
if err != nil {
return
}
}
if this.letting != nil {
err = this.letting.MapExpressions(mapper)
if err != nil {
return
}
}
if this.having != nil {
this.having, err = mapper.Map(this.having)
}
return
}
/*
Applies mapper to all the expressions in the delete statement.
*/
func (this *Delete) MapExpressions(mapper expression.Mapper) (err error) {
if this.keys != nil {
this.keys, err = mapper.Map(this.keys)
if err != nil {
return err
}
}
if this.where != nil {
this.where, err = mapper.Map(this.where)
if err != nil {
return err
}
}
if this.limit != nil {
this.limit, err = mapper.Map(this.limit)
if err != nil {
return err
}
}
if this.returning != nil {
err = this.returning.MapExpressions(mapper)
}
return
}
/*
This method maps all the constituent clauses, namely the expression,
partition and where clause within a create index statement.
*/
func (this *CreateIndex) MapExpressions(mapper expression.Mapper) (err error) {
err = this.exprs.MapExpressions(mapper)
if err != nil {
return
}
if this.partition != nil {
this.partition, err = mapper.Map(this.partition)
if err != nil {
return
}
}
if this.where != nil {
this.where, err = mapper.Map(this.where)
if err != nil {
return
}
}
return
}
/*
This method maps all the constituent clauses, namely the subresult,
order, limit and offset within a Select statement.
*/
func (this *Select) MapExpressions(mapper expression.Mapper) (err error) {
err = this.subresult.MapExpressions(mapper)
if err != nil {
return
}
if this.order != nil {
err = this.order.MapExpressions(mapper)
}
if this.limit != nil {
this.limit, err = mapper.Map(this.limit)
if err != nil {
return
}
}
if this.offset != nil {
this.offset, err = mapper.Map(this.offset)
}
return
}