Merge this Miner's WHERE into the given Miner.

@param  Miner $Miner to merge into
@return Miner
425055
public function mergeWhereInto(Miner $Miner)
    {
        foreach ($this->where as $where) {
            // Handle open/close brackets differently than other criteria.
            if (array_key_exists('bracket', $where)) {
                if (strcmp($where['bracket'], self::BRACKET_OPEN) == 0) {
                    $Miner->openWhere($where['connector']);
                } else {
                    $Miner->closeWhere();
                }
            } else {
                $Miner->where($where['column'], $where['value'], $where['operator'], $where['connector'], $where['quote']);
            }
        }

        return $Miner;
    }
280676
def merge_hashes(hashes)
      hashes.inject({}) { |n, h| n.weave(h, true) }
    end
1349382
public static function merge()
    {
        $args = func_get_args();
        $where = array();
        $options = array();
        foreach ($args as $o) {
            $options = array_merge($options, $o);
            if (isset($o['where'])) {
                if (count($where) === 0) {
                    $where = $o['where'];
                } else {
                    foreach ($o['where'] as $oc) {
                        $matches = 0;
                        foreach ($where as $wc) {
                            if ($oc == $wc) {
                                $matches += 1;
                            }
                        }
                        if ($matches === 0) {
                            $where[] = $oc;
                        }
                    }
                }
            }
        }
        $options['where'] = $where;
        return $options;
    }
1272974
protected function mergePipelines($new)
    {
        if (!isset($this->nodes['pipelines']) || !count($this->nodes['pipelines'])) {
            return $new;
        }

        if (!count($new)) {
            return $this->nodes['pipelines'];
        }

        /** @var array $pipelinesKeys */
        $pipelinesKeys = array_merge(
            array_keys($this->nodes['pipelines']),
            array_keys($new)
        );

        return array_reduce($pipelinesKeys, function($carry, $key) use ($new) {
            $existing = $this->nodes['pipelines'];
            if (!isset($new[$key])) {
                $carry[$key] = $existing;
                return $carry;
            }
            if (!isset($existing[$key])) {
                $carry[$key] = $new[$key];
                return $carry;
            }

            $carry[$key] = $this->mergePipeline($existing[$key], $new[$key]);
            return $carry;
        }, []);
    }
82403
protected function mergePasswordAndSalt($password, $salt)
    {
        if (empty($salt)) {
            return $password;
        }

        if (false !== strrpos($salt, '{') || false !== strrpos($salt, '}')) {
            throw new \InvalidArgumentException('Cannot use { or } in salt.');
        }

        return $password.'{'.$salt.'}';
    }
263474
public function merge($prototype, $operator = 'and')
    {
        if ($prototype instanceof QueryBuilder) {
            $params = $prototype->getParams();
            $prototype = $prototype->toArray();
            $prototype['params'] = $params;
        } elseif($prototype instanceof \T4\Core\IArrayable) {
            $prototype = $prototype->toArray();
        }
        if (!is_array($prototype) && !$prototype instanceof \ArrayAccess) {
            throw new \InvalidArgumentException('Invalid builder type!');
        }
        if (!empty($this->mode) && !empty($prototype['mode']) && $this->mode !== $prototype['mode']) {
            throw new \DomainException('Query mode is not much!');
        }
        if (!empty($prototype['select'])) {
            $this->select($prototype['select']);
        }
        if (!empty($prototype['from'])) {
            $this->from($prototype['from']);
        }
        if (!empty($prototype['where'])) {
            $this->where = empty($this->where) ? $prototype['where'] : "($this->where) $operator ($prototype[where])";
        }
        foreach(['group','order','limit','offset'] as $property) {
            if (!empty($prototype[$property])) {
                $this->$property = $prototype[$property];
            }
        }
        foreach(['joins','params','insertTables','updateTables','deleteTables','values'] as $arrayProperty) {
            if (!empty($prototype[$arrayProperty])) {
                $this->$arrayProperty = array_merge($this->$arrayProperty ?? [], $prototype[$arrayProperty]);
            }
        }
        return $this;
    }
1315394
public function merge($values): Map
    {
        $merged = new self($this);
        $merged->putAll($values);
        return $merged;
    }
196128
public function mergeWith(Address $address): self
    {
        return new static(...\array_merge($this->ipv4, $address->ipv4), ...\array_merge($this->ipv6, $address->ipv6));
    }
952919
public function merge( array $members )
    {
        foreach( $members as $offset => $value ) {
            $this->offsetSet( $offset, $value );
        }
        return $this;
    }
1251939
public function orOn($column1, $column2 = null, $operator = '=')
    {
        return $this->addJoinCondition($column1, $column2, $operator, 'OR');
    }
895546
public function mergeRecord($record) {
    if ($this->isNew()) {
      throw new \Exception('Can not merge, is new');
    }
    foreach ($this->fields as $field_name => $field) {
      if (!empty($record[$field_name])) {
        $this->record[$field_name] = $record[$field_name];
      }
      $this->isDirty = TRUE;
    }

    return $this;
  }
497593
public function merge(Model $object) {
		$mergeData       = $object->toArray();
		$this->_data     = $mergeData + $this->_data;
		$this->_changed += array_fill_keys(array_keys($mergeData), true);
		
		return $this;
	}
1106069
public function merge(ObjectCollectionInterface $collection)
    {
        $this->items = array_merge(
            $this->getItems(),
            $collection->getItems()
        );

        return $this;
    }
730366
public function merge(iterable $values): Sequence
    {
        $items = $this->items->merge($values);

        return $this->duplicate($items);
    }
15366
public function mergeInto(Miner $Miner, $overrideLimit = true)
    {
        if ($this->isSelect()) {
            $this->mergeSelectInto($Miner);
            $this->mergeFromInto($Miner);
            $this->mergeJoinInto($Miner);
            $this->mergeWhereInto($Miner);
            $this->mergeGroupByInto($Miner);
            $this->mergeHavingInto($Miner);
            $this->mergeOrderByInto($Miner);
            
            if ($overrideLimit) {
                $this->mergeLimitInto($Miner);
            }
        } elseif ($this->isInsert()) {
            $this->mergeInsertInto($Miner);
            $this->mergeSetInto($Miner);
        } elseif ($this->isReplace()) {
            $this->mergeReplaceInto($Miner);
            $this->mergeSetInto($Miner);
        } elseif ($this->isUpdate()) {
            $this->mergeUpdateInto($Miner);
            $this->mergeJoinInto($Miner);
            $this->mergeSetInto($Miner);
            $this->mergeWhereInto($Miner);
            
            // ORDER BY and LIMIT are only applicable when updating a single table.
            if (! $this->join) {
                $this->mergeOrderByInto($Miner);
                
                if ($overrideLimit) {
                    $this->mergeLimitInto($Miner);
                }
            }
        } elseif ($this->isDelete()) {
            $this->mergeDeleteInto($Miner);
            $this->mergeFromInto($Miner);
            $this->mergeJoinInto($Miner);
            $this->mergeWhereInto($Miner);
            
            // ORDER BY and LIMIT are only applicable when deleting from a single
            // table.
            if ($this->isDeleteTableFrom()) {
                $this->mergeOrderByInto($Miner);
                
                if ($overrideLimit) {
                    $this->mergeLimitInto($Miner);
                }
            }
        }
        
        return $Miner;
    }
891941
public function leftJoinWhere($table, $one, $operator, $two)
    {
        return $this->joinWhere($table, $one, $operator, $two, 'left');
    }
1141575
public function mergeUpdateInto(Miner $Miner)
    {
        $this->mergeOptionsInto($Miner);

        if ($this->update) {
            $Miner->update($this->getUpdate());
        }

        return $Miner;
    }