Merge this Miner's INTOCOLUMS into the given Miner.

@param  Miner $Miner to merge into
@return Miner
193236
public function mergeIntoColumns(Miner $Miner)
    {
        if ($this->intoColums) {
            $Miner->intoColumns($this->intoColums);
        }

        return $Miner;
    }
1264099
public function merge(NestedMember $member) : NestedMember
    {
        $parts = $this->parts;

        $isNullable = $this->getResultingType()->isNullable();
        foreach ($member->getParts() as $part) {
            $parts[] = $isNullable ? $part->asNullable() : $part;
        }

        return new self($parts);
    }
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;
    }
698990
public function mergeFromInto(Miner $Miner)
    {
        if ($this->from) {
            $Miner->from($this->getFrom(), $this->getFromAlias());
        }

        return $Miner;
    }
1009207
public function mergeDeleteInto(Miner $Miner)
    {
        $this->mergeOptionsInto($Miner);

        if ($this->isDeleteTableFrom()) {
            $Miner->delete();
        } else {
            foreach ($this->delete as $delete) {
                $Miner->delete($delete);
            }
        }

        return $Miner;
    }
784350
public function merge($pk, array $rows, $alias, $slaveTable, $slaveColumnId)
    {
        foreach ($rows as &$row) {
            // Extra check
            if (isset($row[$pk])) {
                $value = $row[$pk];

                // Prepare slave set
                $slaveSet = $this->querySlaveTable($slaveTable, $slaveColumnId, $value);
                $slaveSet = $this->getResultSetWithoutSlaveColumnId($slaveSet, $slaveColumnId);

                $row[$alias] = $slaveSet;
            }
        }

        return $rows;
    }
689396
public function mergeTable($table, $sql) {
        return $this->command()->execute('CREATE TABLE '.$this->addPrefix($table).' AS '.$sql);
    }
393009
public function merge( LogDataInterface $log ) {

		$log_data = [
			self::MESSAGE => $log->message(),
			self::LEVEL   => $log->level(),
			self::CHANNEL => $log->channel(),
			self::CONTEXT => $log->context(),
		];

		return $this->merge_array( $log_data );
	}
696895
private function mergeRules()
    {
        $rules = static::$rules;
        $output = array();

        if (empty ($rules))
        {
            return $output;
        }

        if ($this->exists)
        {
            $merged = (isset($rules['update'])) ? array_merge_recursive($rules['save'], $rules['update']) : $rules['save'];
        } else
        {
            $merged = (isset($rules['create'])) ? array_merge_recursive($rules['save'], $rules['create']) : $rules['save'];
        }

        foreach ($merged as $field => $rules)
        {
            if (is_array($rules))
            {
                $output[$field] = implode("|", $rules);
            } else
            {
                $output[$field] = $rules;
            }
        }

        return $output;
    }
1322205
public function merge(Collection $collection) {
		if ($collection->isEmpty()) {
			return $this;
		}
		
		$primary = $this->getPrimary();
		
		if ($primary !== null) {
			$sourcePrimary = $collection->getPrimary();
		
			if ($primary !== $sourcePrimary) {
				$collection = clone $collection;
				$collection->setPrimary($primary);
			}
		}
		
		$data   = &$collection->getDataLinked();
		$models = $collection->getInstancedModels();
		
		if ($primary === null) {
			$this->_data = array_merge($this->_data, $data);
			
			if (! empty($models)) {
				$this->_models = array_merge($this->_models , $models);
			}
		} else {
			$this->_data = $data + $this->_data;
			
			if (! empty($models)) {
				$this->_models = $models + $this->_models;
			}
		}
		
		$this->_pointer = 0;
		$this->_map     = array_keys($this->_data);
		
		return $this;
	}
834625
public function mergeSelectInto(Miner $Miner)
    {
        $this->mergeOptionsInto($Miner);

        foreach ($this->select as $column => $alias) {
            $Miner->select($column, $alias);
        }

        return $Miner;
    }
746521
public function mergeGroupByInto(Miner $Miner)
    {
        foreach ($this->groupBy as $groupBy) {
            $Miner->groupBy($groupBy['column'], $groupBy['order']);
        }

        return $Miner;
    }
1071459
final public function addAggregateColumn(Aggregate $aggregate)
    {
        $parts = explode(".", $aggregate->getAggregateColumnName());

        if (count($parts) > 1) {
            $columnName = $parts[count($parts) - 1];

            $relationships = array_slice($parts, 0, count($parts) - 1);

            $aggregate->setAliasDerivedColumn(str_replace(".", "", $aggregate->getAggregateColumnName()));
            $aggregate->setAggregateColumnName($columnName);

            $collection = $this->createIntersectionForRelationships($relationships, [$aggregate->getAlias()]);
            $collection->addAggregateColumn($aggregate);
            return $this;
        }

        $this->aggregateColumns[$aggregate->getAlias()] = $aggregate;
        $this->invalidate();

        return $this;
    }
803054
public function merge($image, int $model = 10)
    {
        $image = self::encode($image);

        return Request::exec(self::MERGE, compact('model', 'image'));
    }
159217
public function mergeWith(self $objects): self
    {
        $clone = clone $this;
        foreach ($objects->objects as $reference => $object) {
            $clone->objects[$reference] = $object;
            $clone->array[$reference] = $object->getInstance();
        }
        
        return $clone;
    }
441012
public function merge(Set $rules): self
    {
        $this->rules = array_merge($this->rules, $rules->rules);
        return $this;
    }
933507
public function addMatchColumn($column)
    {
        $this->matchColumns->push($column instanceof Expression ? $column : new Column($column));
        
        return $this;
    }