Add conjunction to Search.

@param string $conjunction Search conjunction
@return void
@throws \RuntimeException When invalid filter class is provided
519880
public function setConjunction(string $conjunction = self::DEFAULT_CONJUNCTION) : void
    {
        if (! in_array($conjunction, self::CONJUNCTIONS)) {
            throw new \RuntimeException(sprintf('Invalid conjunction provided: %s', $conjunction));
        }

        $this->conjunction = $conjunction;
    }
1007478
public void combine(SearchFilter new_filter, int op) throws DBException
    {
        // If this is not a logical operator, throw an exception
        if ((op & LOGICAL_OPER_MASK) == 0)
        {
            throw new DBException();
            // Create a new vector consisting of just the filters
            // from the SearchFilter classes in new_filters
        }
        Vector filters = new Vector();
        filters.addElement(new_filter.getFilter());
        // Create a node for this list and return it
        m_filter = new SearchBaseNode(op, m_filter, filters);
    }
1215202
private function parentIsFromProvider($conjunction, $parentProviderName)
    {
        if (!empty($this->expression)) {
            $this->expression[] = $conjunction;
        }

        $index              = \count($this->variables);
        $this->expression[] = \sprintf(self::PARENT_IS_FROM_PROVIDER_EXPRESSION, $index);
        $this->variables[]  = $parentProviderName;
        $this->compiled     = null;

        return $this;
    }
1307030
private function actionIsIn($conjunction, array $actions)
    {
        if (!empty($this->expression)) {
            $this->expression[] = $conjunction;
        }

        $expression = [];
        foreach ($actions as $action) {
            $index             = \count($this->variables);
            $expression[]      = \sprintf(self::ACTION_IS_EXPRESSION, $index);
            $this->variables[] = $action;
        }
        $this->expression[] = '(' . \implode(' or ', $expression) . ')';
        $this->compiled     = null;

        return $this;
    }
357905
public function regexp($column, $regexp, $conjunction = 'AND')
    {
        return $this->addExpression(new Condition\Regexp($column, $regexp, $conjunction));
    }
972024
public void combine(SearchFilter new_filter, int op) throws DBException
    {

        // cast down to OJBSearchFilter
        OJBSearchFilter ojbFilter = (OJBSearchFilter) new_filter;

        switch (op)
        {

            case OR:
                {
                    criteria.addOrCriteria(ojbFilter.getCriteria());
                    break;
                }

            case AND:
                {
                    criteria.addAndCriteria(ojbFilter.getCriteria());
                    break;
                }

            default:
                {
                    throw new DBException();
                }
        }
    }
437324
public function addOr(Criterion $criterion)
    {
        $this->clauses[] = $criterion;
        $this->conjunctions[] = self::ODER;

        return $this;
    }
781880
public function addToQuery(&$query)
    {
        parent::addToQuery($query);

        foreach ($this->compositeDatabaseFields() as $field => $spec) {
            $table = $this->getTable();
            $key = $this->getName() . $field;
            if ($table) {
                $query->selectField("\"{$table}\".\"{$key}\"");
            } else {
                $query->selectField("\"{$key}\"");
            }
        }
    }
792070
public function setConjunction($conjunction)
    {
        if ((static::AND_CONJUNCTION !== $conjunction) && (static::OR_CONJUNCTION !== $conjunction)) {
            throw new DcGeneralInvalidArgumentException(
                'Conjunction must be ConditionChainInterface::AND_CONJUNCTION ' .
                'or ConditionChainInterface::OR_CONJUNCTION'
            );
        }

        $this->conjunction = (string) $conjunction;

        return $this;
    }
271778
public function addWhereClause($clause)
    {
        if (null === $this->whereClause) {
            $this->whereClause = "WHERE {$clause}".PHP_EOL;
        } else {
            $this->whereClause = $this->whereClause."AND {$clause}".PHP_EOL;
        }
    }
1095048
public function addHavingCondition(Expression $left, Expression $right, $comparator, $conjunction = Cmp::CONJUNCTION_AND)
    {
        $this->getHavingStatement()->add($left, $right, $comparator, $conjunction);
        
        return $this;
    }
97314
public function addFilter(Filter $filter)
    {
        $key = $filter->getKey();
        $this->filters[$key] = $filter;
    }
1021846
public function addAnd(Criterion $criterion)
    {
        $this->clauses[] = $criterion;
        $this->conjunctions[] = self::UND;

        return $this;
    }
1248978
private void add(ClassFilter filter) {
        switch(operator) {
        case NOT:
            filters.add(new NegationClassFilter(filter));
            operator = Operator.NONE;
            break;
        case OR:
            filters.set(filters.size() - 1, 
                        new OrClassFilter(filters.get(filters.size() - 1), filter));
            operator = Operator.NONE;
            break;
        default:
            filters.add(filter);
            break;
        }
    }
688718
public void append(final Filter query) {
        switch (this.queryType) {
            case OR: {
                this.orFilter.or(query);
            }
            break;

            default:
            case AND: {
                this.andFilter.and(query);
            }
            break;
        }
    }
42444
protected function compileConditions(array $conditions, $conjunction = null)
    {
        if (count($conditions) === 1) {
            return $conditions[0];
        }

        if ($conjunction === null) {
            $conjunction = $this->conjunction();
        }

        return '('.implode(' '.$conjunction.' ', $conditions).')';
    }
813877
public function addLogicalOperator($operator)
    {
        if ($this->_mode === self::GM_SIGNS) {
            include_once 'Zend/Search/Lucene/Search/QueryParserException.php';
            throw new Zend_Search_Lucene_Search_QueryParserException('It\'s not allowed to mix boolean and signs styles in the same subquery.');
        }

        $this->_mode = self::GM_BOOLEAN;

        $this->_entries[] = $operator;
    }