- Chancge foreign key
@param stdClass $variable Content variables for execute functionality
@return null
337845
public function withoutReference(stdClass $variable) {
    (new WithoutReference())->render($this->pdo, $this->info, $variable, $this->output);
  }
872967
public function getInferedType($variable)
    {
        if (isset($this->variables[$variable])) {
            $type = $this->variables[$variable];
            if ('variable' != $type && 'undefined' != $type && 'string' != $type && 'istring' != $type && 'array' != $type && 'null' != $type && 'numeric' != $type) {
                //echo $variable, ' ', $type, PHP_EOL;
                return $type;
            }
        }

        return false;
    }
412209
public function assign($var, $value = null)
    {
        if (is_string($var)) {
            $this->_vars[$var] = $value;

            return $this;
        }

        if (is_array($var)) {
            foreach ($var as $key => $value) {
                if ($value instanceof AbstractClassContent) {
                    // trying to load subcontent
                    $subcontent = $this->getApplication()
                            ->getEntityManager()
                            ->getRepository(ClassUtils::getRealClass($value))
                            ->load($value, $this->getApplication()->getBBUserToken());
                    if (null !== $subcontent) {
                        $value = $subcontent;
                    }
                }

                $this->_vars[$key] = $value;
            }
        }

        return $this;
    }
1215520
protected function evalVarDesc($variable, $key)
    {
        $type = $this->getType($variable);

        if ($type == 'method') {
            return $this->evalMethodDesc($variable);
        }

        if (isset($this->commentMap[$key])) {
            return $this->commentMap[$key];
        }

        if ($type == 'array') {
            return $this->evalArrDesc($variable);
        }

        if ($type == 'object') {
            return $this->evalObjDesc($variable);
        }

        return '';
    }
173276
public static function get($variable) {
		self::startSessionIfNeeded();
		// If it exists, and we do not want to overwrite, then throw exception
		if (! self::has($variable)) {
			throw new \Exception("{$variable} does not exist in the store.");
		}

		return unserialize($_SESSION[$variable]);
	}
968220
function by(Row $foreign, $ref = null) {
		// select * from $this where $this->$referencedColumn = $me->$foreignColumn
		
		if (!($rel = $foreign->getTable()->getRelation($this->getName(), $ref))) {
			return $this->onResult(null);
		}
		
		$where = array();
		foreach ($rel as $key => $ref) {
			$where["$ref="] = $foreign->$key;
		}
		return $this->find($where);
	}
382591
public static function remove($variable) {
		self::startSessionIfNeeded();
		// If it exists, and we do not want to overwrite, then throw exception
		if (! self::has($variable)) {
			throw new \Exception("{$variable} does not exist in the store.");
		}

		// Unset the variable
		unset($_SESSION[$variable]);

		// Was it removed
		return ! self::has($variable);
	}
795276
public static function header(string $variable, $default=null) {
		return isset(self::$_headers[$variable])
			? self::$_headers[$variable]
			: $default;
	}
76074
public function delete(string $variable, bool $detach = false): self
    {
        $query = new self;
        $query->clauses = $this->clauses->add(
            new Clause\DeleteClause($variable, $detach)
        );

        return $query;
    }
1249973
public function get($variable)
    {
        if (false === array_key_exists($variable, $this->variables)) {
            throw new View\Exception(sprintf('Unassigned variable "%s"', $variable));
        }

        return $this->variables[$variable];
    }
1342902
public static function getTypeFromPHPVariable($variable)
    {
        if ($variable === null) {
            throw ODMException::cannotInferTypeFromNullValue();
        }

        $phpType = gettype($variable);
        
        if ($phpType === 'string') {
            if ($variable === '') {
                throw new \InvalidArgumentException;
            }

            return self::getType(Type::STRING);
        }

        if ($phpType instanceof NumberValue) {
            //use type coercion to determine the actual php type
            $phpType = gettype((string)$variable + 0);
        }

        if ($phpType === 'integer') {
            return self::getType(Type::INT);
        }

        if ($phpType === 'double') {
            return self::getType(Type::FLOAT);
        }

        if (is_resource($variable) || $variable instanceof StreamInterface || $variable instanceof BinaryValue) {
            return self::getType(Type::BIN);
        }

        if ($phpType === 'object') {
            if ($variable instanceof SetValue) {
                return self::getType(Type::SET);
            }

            if (!$variable instanceof \Traversable && !$variable instanceof \stdClass) {
                throw ODMException::unmappedObjectSerializationNotSupported();
            }

            //Traversable objects fall through to the array case
            $phpType = 'array';
        }

        if ($phpType === 'array') {
            $i = 0;
            foreach ($variable as $k => $v) {
                if (!is_int($k) || $k != $i++) {
                    return self::getType(Type::MAP);
                }
            }

            return self::getType(Type::LIST_);
        }

        if ($phpType === 'boolean') {
            return self::getType(Type::BOOL);
        }

        //NULL, closed resource or unknown type
        throw new \InvalidArgumentException;
    }
734979
public function first(): ?\stdClass
    {
        $pdoStatement = $this->provideStatement();
        $pdoStatement = $this->execute($pdoStatement);
        $row = $pdoStatement->fetch(\PDO::FETCH_OBJ);
        return (!empty($row)) ? $row : null;
    }
363981
public function csv(stdClass $variable) {
    (new Csv())->render($this->pdo, $this->info, $variable, $this->output);
  }
939470
public function handle(VariableRepositoryInterface $variables)
    {
        if (!$group = $variables->group($this->group)) {
            return null;
        }

        return (new Decorator())->decorate($group)->{$this->field};
    }
1234569
public function setFieldId($var)
    {
        GPBUtil::checkMessage($var, \Google\Cloud\Dlp\V2\FieldId::class);
        $this->field_id = $var;

        return $this;
    }
327322
public function through(
        string $variable = null,
        string $type = null,
        string $direction = 'BOTH'
    ): self {
        if ($this->elements->size() < 3) {
            throw new LogicException;
        }

        $direction = \strtolower($direction);

        $path = new self;
        $path->elements = $this
            ->elements
            ->dropEnd(2)
            ->add(Relationship::$direction($variable, $type))
            ->add($this->elements->last());
        $path->lastOperation = Relationship::class;

        return $path;
    }
100863
public static function cast($variable, string $type)
    {
        $type = self::normalise($type);

        if ( ! method_exists(__CLASS__, "cast_$type"))
        {
            throw new Exception(
                "Type $type could not be casted: method not implemented."
            );
        }

        return self::{"cast_$type"}($variable);
    }