/* This method fully qualifies the identifiers for each term in the result expression. It disallows duplicate alias and exempts explicit aliases from being formalized. */ func (this *Projection) Formalize(in *expression.Formalizer) (f *expression.Formalizer, err error) { // Disallow duplicate aliases aliases := make(map[string]bool, len(this.terms)) for _, term := range this.terms { if term.alias == "" { continue } if aliases[term.alias] { return nil, fmt.Errorf("Duplicate result alias %s.", term.alias) } aliases[term.alias] = true } err = this.MapExpressions(in) if err != nil { return } if len(aliases) > 0 { f = in.Copy() } else { f = in } // Exempt explicit aliases from being formalized for _, term := range this.terms { if term.as != "" { f.Allowed().SetField(term.as, term.as) } } return }
/* Qualify all identifiers for the parent expression. Checks is a nest alias exists and if it is a duplicate alias. */ func (this *IndexNest) Formalize(parent *expression.Formalizer) (f *expression.Formalizer, err error) { f, err = this.left.Formalize(parent) if err != nil { return } _, ok := f.Allowed.Field(this.keyFor) if !ok { err = errors.NewUnknownForError("NEST", this.keyFor, "plan.nest.unknown_for") return nil, err } alias := this.Alias() if alias == "" { err = errors.NewNoTermNameError("NEST", "plan.nest.requires_name_or_alias") return nil, err } _, ok = f.Allowed.Field(alias) if ok { err = errors.NewDuplicateAliasError("NEST", alias, "plan.nest.duplicate_alias") return nil, err } f.Allowed.SetField(alias, alias) f.Keyspace = "" var p *expression.Formalizer if parent != nil { p = parent.Copy() } else { p = expression.NewFormalizer() } p.Allowed.SetField(alias, alias) this.right.keys, err = p.Map(this.right.keys) return }