Translates {@link Union}.

@param union a union.
@return union translation.
497696
public String translate(final Union union) {
        final List<Expression> expressions = union.getExpressions();
        final String delimiter = union.isAll() ? " UNION ALL " : " UNION ";

        inject(expressions);
        final String translation = expressions.stream()
                .map(Expression::translate)
                .collect(Collectors.joining(delimiter));
        return union.isEnclosed() ? "(" + translation + ")": translation;
    }
987829
public void union(Viewport v) {
        union(v.left, v.top, v.right, v.bottom);
    }
1129773
public static <E> Collection<E> unionColl(Collection<E> c1, Collection<E> c2) {
	return new UColl<E>(c1, c2);
    }
606027
public IntBiMap union(IntBiMap other) {
    int newLength = keys.length + other.keys.length;

    int[] newKeys = Arrays.copyOf(keys, newLength);
    ArrayUtils.copy(other.keys, 0, newKeys, keys.length, other.keys.length);
    int[] newValues = Arrays.copyOf(values, newLength);
    ArrayUtils.copy(other.values, 0, newValues, values.length, other.values.length);

    return IntBiMap.fromUnsortedKeyValues(newKeys, newValues);
  }
337373
public ModelNode translateOperationForProxy(final ModelNode op) {
        return translateOperationForProxy(op, PathAddress.pathAddress(op.get(OP_ADDR)));
    }
322664
public static Assignment unionAll(Collection<Assignment> assignments) {
    int numVars = 0;
    for (Assignment assignment : assignments) {
      numVars += assignment.size();
    }

    int[] vars = new int[numVars];
    Object[] values = new Object[numVars];
    int numFilled = 0;
    for (Assignment assignment : assignments) {
      int[] assignmentVars = assignment.vars;
      Object[] assignmentValues = assignment.values;
      int numAssignmentVars = assignment.vars.length;
      for (int i = 0; i < numAssignmentVars; i++) {
        vars[numFilled] = assignmentVars[i];
        values[numFilled] = assignmentValues[i];
        numFilled++;
      }
    }
    Preconditions.checkState(numFilled == numVars);
    return Assignment.fromUnsortedArrays(vars, values);
  }
498920
public function addUnion($union)
    {
        if (null === $union)
            return $this;
        if (!isset($this->query['union'])) {
            $this->query['union'] = [];
        }
        $this->query['union'][] = $union;
        return $this;
    }
6580
public static <T extends Comparable<T>> RangeSet<T> unionRanges(final Iterable<Range<T>> ranges)
  {
    RangeSet<T> rangeSet = null;
    for (Range<T> range : ranges) {
      if (rangeSet == null) {
        rangeSet = TreeRangeSet.create();
      }
      rangeSet.add(range);
    }
    return rangeSet;
  }
103096
func (b *Builder) Union(unionTp string, unionCond *Builder) *Builder {
	var builder *Builder
	if b.optype != unionType {
		builder = &Builder{cond: NewCond()}
		builder.optype = unionType
		builder.dialect = b.dialect
		builder.selects = b.selects

		currentUnions := b.unions
		// erase sub unions (actually append to new Builder.unions)
		b.unions = nil

		for e := range currentUnions {
			currentUnions[e].builder.dialect = b.dialect
		}

		builder.unions = append(append(builder.unions, union{"", b}), currentUnions...)
	} else {
		builder = b
	}

	if unionCond != nil {
		if unionCond.dialect == "" && builder.dialect != "" {
			unionCond.dialect = builder.dialect
		}

		builder.unions = append(builder.unions, union{unionTp, unionCond})
	}

	return builder
}
238407
public <RT> Union<RT> unionAll(SubQueryExpression<RT>... sq) {
        unionAll = true;
        return innerUnion(sq);
    }
626456
private function prepareUnion(array $union)
    {
        if ($union['sql'] instanceof self) {
            [$sql, $params] = $union['sql']->toSql();

            $union['sql'] = $sql;

            $union['params'] = $params;
        }

        return $union;
    }
825657
public <T extends JCTree> T translate(T tree, Type pt) {
        Type prevPt = this.pt;
        try {
            this.pt = pt;
            return translate(tree);
        } finally {
            this.pt = prevPt;
        }
    }
880635
@Override
   public DefaultConsistentHash union(DefaultConsistentHash dch1, DefaultConsistentHash dch2) {
      return dch1.union(dch2);
   }
1148463
public static <T> Union<T> unionAll(SubQueryExpression<T>... sq) {
        return new SQLQuery<Void>().unionAll(sq);
    }
579280
public static String[] union(String[] arr1, String[] arr2) {
		Set<String> set = new HashSet<String>();
		for (String str : arr1) {
			set.add(str);
		}
		for (String str : arr2) {
			set.add(str);
		}
		String[] result = {};
		return set.toArray(result);
	}
485274
Lexicon union(Lexicon that) {
    return new Lexicon(fallback(words, that.words), Parsers.or(tokenizer, that.tokenizer));
  }
127475
public static GeoShape.Union union(String... shapes) {
        return union(Stream.of(shapes).map(Builder::wkt).collect(Collectors.toList()));
    }