Adds new join to the pool.

@param string $table
@param string $key
@param string $operator
@param string $value
@param string $type
@return void
509083
protected function addJoin(
        string $table,
        string $key,
        string $operator,
        string $value,
        string $type = 'inner'
    ): void {
        array_push($this->join, [
            'table' => $table,
            'key' => $key,
            'operator' => $operator,
            'value' => $value,
            'type' => $type,
        ]);
    }
733041
private function clauseJoin($table,$column,$operator,$value, $scape_quote,$type) {
      $closure = false;
      $type = strtoupper($type);
      $this->connection();
      $schema = $this->schema?"{$this->schema}.":'';

      if (is_array($column)) {
         foreach ($column as $key => $val) {
            // $this->operators
            if (preg_match('/([\.a-zA-Z0-9_-]+) *(.*)/i', $key,$match)) {
               if (trim($match[2])) {
                  $this-> clauseJoin($table,trim($match[1]), trim($match[2]), $val, $scape_quote, $type);
               }
               else {
                  $this-> clauseJoin($table,trim($match[1]), $val, $value, $scape_quote, $type);
               }
            }
         }
         return;
      }

      // si es un closure lo ejecutamos
      if ($column instanceof \Closure) {
         // el resultado resuelto es almacenado en la variable $_ENV para luego terminar de agruparlo
         $column(new \Daniia\Daniia());
         $str = $_ENV["daniia_daniia"]->on;
         $_ENV["daniia_daniia"] = null;
         $closure = true;
      }

      // si no es un operador valido
      if ( $operator instanceof \Closure ) {
         list($operator, $value, $scape_quote) = ['=', $operator, $value];
      }elseif ( is_array($operator) ) {
         list($operator, $value, $scape_quote) = ['in', $operator, $value];
      }elseif ( !in_array(strtolower(trim($operator)), $this->operators, true) ) {
         list($operator, $value, $scape_quote) = ['=', $operator, $value];
      }

      if ($value instanceof \Closure) {
         // el resultado resuelto es almacenado en la variable $_ENV para luego terminar de agruparlo
         $value(new \Daniia\Daniia());
         $get_sql = $_ENV["daniia_daniia"]->get_sql();
         $_ENV["daniia_daniia"] = null;
         $value = $get_sql;
      }

      if( is_array($value) ) {
         $in = [];
         foreach($value as $val){
            if ( $val===NULL ) {
               $in[] = ' NULL ' ;
            }
            elseif ( gettype($val)==='boolean' ) {
               $in[] = $val ? ' TRUE ' : ' FALSE ' ;
            }
            else {
               $in[] = $this->id_conn->quote($val);
            }
         }
         $scape_quote = FALSE;
         $value = ' ('.implode(',',$in).') ';
      }
      elseif ( $value===NULL ) {
         $scape_quote = FALSE;
         $value = ' NULL ' ;
      }
      elseif ( gettype($value)==='boolean' ) {
         $scape_quote = FALSE;
         $value = $value ? ' TRUE ' : ' FALSE ' ;
      }

      if (!$closure) {
         $str = $column.' '.strtoupper($operator).' '.($scape_quote?$this->id_conn->quote($value):$value);
         $this->join .= " {$type} JOIN {$schema}{$table} ON {$str} ";
      }
      else {
         $this->join .= " {$type} JOIN {$schema}{$table} {$str} ";
      }

      $this->get_instance();
      return $this;
   }
170867
private function join($type, $table, $col, $op, $col2 = '')
    {
        $col = $this->formatColumn($col);
        $col2 = $this->formatColumn($col2);
        $this->_sql['join'][$type][] = [$table, $col, $op, $col2];
        return $this;
    }
632350
public function set($key, $value, $type=null) {
		if($type === null)
			$res = serialize($value);
		else {
			$res = serialize(array(
				'_dataType' => $type,
				'input' => $this->types[$type][0]($value)
			));
		}
		$dal = $this->db->dal();
		if(!$dal->from($this->getTable())->where('key', $key)->update(array('value'=>$res)))
			$dal->into($this->getTable())->insert(array('key'=>$key, 'value'=>$res));
	}
316909
public function leftJoin(string $table, string $key, string $operator, string $value): SelectQueryBuilder
    {
        $this->addJoin($table, $key, $operator, $value, 'left');
        return $this;
    }
172134
protected function addSimpleWhere(string $key, string $operator, $value): void
    {
        $placeholder = $this->addBindingValue($key, $value);
        $key = $this->quoteName($key);
        $this->statement .= sprintf('%s %s %s', $key, $operator, $placeholder);
        $this->statement .= PHP_EOL;
    }
931468
public function addJoin($join_field, $alias, $type = Join::INNER_JOIN, $cond = '')
    {
        $this->_queryBuilder->addJoin($join_field, $alias, $type, $cond);
        return $this;
    }
751897
protected function join(
        $type,
        $joinTableName,
        $key,
        $comparator,
        $value = null,
        $shouldCompareFields = true,
        $tableName = null
    ) {
        if (!$tableName) {
            $tableName = $this->getTableName();
        }

        $condition = new \Parable\ORM\Query\Condition();
        $condition
            ->setQuery($this)
            ->setTableName($tableName)
            ->setJoinTableName($joinTableName)
            ->setKey($key)
            ->setComparator($comparator)
            ->setValue($value)
            ->setShouldCompareFields($shouldCompareFields);

        $this->joins[$type][] = $condition;
        return $this;
    }
1068202
function join (table, args, type) {
    this.typecheck && t.typecheck('join', [table, args, type]);
    if ('string'===typeof args) args = [args];
    var result = ['join',table,'on',args.join(' and ')];
    if (type) result.splice(0,0,type);
    return result.join(' ');
}
1048011
private function addWhere($field, $operator, $value = null)
    {
        $this->wheres[] = [
            'field' => $field,
            'operator' => $this->getOperator($operator),
            'value' => $this->connection->escape($value),
        ];
    }
219421
protected function addSearchJoin(Builder $query, $joining_table, $foreign_key, $related_key, $alias)
    {
        // We need to join to the intermediate table
        $local_table = $this->getModel()->getTable();

        // Set the way the table will be join, with an alias or without
        $table = $alias ? "{$joining_table} as {$alias}" : $joining_table;

        // Create an alias for the join
        $alias = $alias ?: $joining_table;

        // Create the join
        $query->join($table, "{$alias}.{$foreign_key}", "{$local_table}.{$related_key}");

        return $alias;
    }
524543
public function where($key, $operator, $value)
    {
        if (string_has($operator, 'IN') || string_has($operator, 'in')) {
            return $this->whereIn($key, $value);
        }

        $this->where[] = 'AND '.$key.' '.$operator.' '.'?';
        $this->bindings[] = $value;

        return $this;
    }
543445
private function join(string $type, $source, $table, $on = null, array $params = [])
    {
        if ($source) {
            $source = $this->getSourceName($source);
        }

        [$tableAlias, $tableName] = $this->dialect()->parseTable($table);

        if ($tableName instanceof SelectQuery) {
            if (!$tableAlias) {
                throw new SqlException('JOIN table should have an alias name.');
            }

            $tableKey = $tableAlias;
        } else {
            $tableKey = $tableAlias ?: $tableName;

            $tableName = $this->dialect()->quoteTable($tableName);
        }

        if ($tableAlias) {
            $tableAlias = $this->dialect()->quoteName($tableAlias);
        }

        if (is_callable($on)) {
            $conditions = new Conditions($this->dialect());

            call_user_func_array($on, [$conditions]);

            $on = $conditions;
        }

        if (is_scalar($on)) {
            $on = $this->dialect()->quote($on);
        }

        $this->addJoin($tableKey, $type, $source, $tableName, $tableAlias, $on, $params);

        return $this;
    }
467458
public function join($table, $on = null, $using = null, $type = 'JOIN')
    {
        $this->from->addJoin($table, $on, $using, $type);

        return $this;
    }
553510
public function join($table, $foreignKey1, $operator, $foreignKey2, $relation = "INNER")
    {
        $self               = self::getInstance();
        $self->optionJoin[] = " {$relation} JOIN {$table} ON {$foreignKey1}{$operator}{$foreignKey2}";
        return $self;
    }
639901
public function join($type, $table, array $relations = array())
    {
        $this->append(sprintf(' %s JOIN %s ', $type, $table));

        // Append relations if provided
        if (!empty($relations)) {
            // First on
            $this->on();

            $i = 0; // Iteration counter
            $count = count($relations);

            foreach ($relations as $column => $value) {
                // Increment iteration count
                $i++;

                $this->equals($column, $value);

                // If last iteration
                if ($i != $count) {
                    $this->rawAnd();
                }
            }
        }

        return $this;
    }
389373
public function addTypedKeyValue($type, $key, $value)
    {
        if(empty($this->_data[$type]))
            $this->_data[$type] = array();
        $this->_data[$type][$key] = $value;
    }