@param string   $table
@param \Closure $callback

@return BaseQueryRelateContract
428180
public function leftJoinClosure(string $table, \Closure $callback): BaseQueryRelateContract
    {
        $this->query->leftjoin($table, $callback);

        return $this;
    }
586783
public function attachment(Closure $callback)
    {
        $this->attachments[] = $attachment = new Attachment;

        $callback($attachment);

        return $this;
    }
125844
public function table($table, Closure $callback)
    {
        $this->build($this->createBlueprint($table, $callback));
    }
557245
public function execute(\Closure $callback)
    {
        $this->action = self::NODE_ACTION_EXECUTE;
        $this->data['callback'] = $callback;
        return $this;
    }
573125
public function fullJoin($table, Closure $closure)
    {
        $this->sql->addJoinClause('FULL', $table, $closure);
        return $this;
    }
161961
public static function createTable($table, callable $callback) {
        $table = new Table($table);
        call_user_func($callback, $table);
        return $table->create();
    }
262029
protected function createBlueprint($table, Closure $callback = null)
    {
        $blueprint = new OracleBlueprint($table, $callback);
        $blueprint->setTablePrefix($this->connection->getTablePrefix());

        return $blueprint;
    }
479943
public static function create($table, $callback)
	{
		$table = new Table($table);

		// To indicate that the table is new and needs to be created, we'll run
		// the "create" command on the table instance. This tells schema it is
		// not simply a column modification operation.
		$table->create();

		call_user_func($callback, $table);

		return static::execute($table);
	}
858199
public function createTable($table, Closure $callback)
    {
    	if($this->hasTable($table)) {
    		return hst_message('is has table');
    	}
        \Schema::connection($this->databaseName)->create($table, $callback);
		return true;
    }
1231556
public function join(string $table, string $one, string $operator = '=', string $two = ''): BaseQueryRelateContract
    {
        $this->query->join($table, $one, $operator, $two);

        return $this;
    }
401001
public function hasAndBelongsTo($entity, callable $callback = null, $alias = null)
    {
        return $this->returnRelation(HasAndBelongsTo::class, $entity, $callback, $alias);
    }
1229374
protected function resolveSubQueryClosure(\Closure $callback): Query
    {
        if ($this->closureResolver === null) {
            return $this->makeCopyForSubQuery()->apply($callback);
        } else {
            return $this->closureResolver->resolveSubQueryClosure($callback);
        }
    }
731117
public function create($table, Closure $closure)
    {
        $blueprint = $this->createBlueprint($table, $closure);
        $blueprint->create();
    }
339840
public function table($table, \Closure $callback)
	{
		try
		{
			parent::create($table, $callback);
		}
		catch(\Exception $e)
		{
			try
			{
				parent::table($table, $callback);
			}
			catch(\Exception $e)
			{
				echo $e->getMessage();
			}
		}
	}
560645
public function pretend( Closure $callback ) {
		return $this->withFreshQueryLog( function () use ( $callback ) {
			$this->pretending = true;

			// Basically to make the database connection "pretend", we will just return
			// the default values for all the query methods, then we will return an
			// array of queries that were "executed" within the Closure callback.
			$callback( $this );

			$this->pretending = false;

			return $this->getLogger()->getQueryLog();
		} );
	}
1282314
public function setConstraint(Closure $callback)
    {
        $this->data            = [];
        $this->loaded          = false;
        $this->queryConstraint = $callback;

        return $this;
    }
370237
public static function noConstraints(Closure $callback)
    {
        static::$constraints = false;

        // When resetting the relation where clause, we want to shift the first element
        // off of the bindings, leaving only the constraints that the developers put
        // as "extra" on the relationships, and not original relation constraints.
        $results = call_user_func($callback);

        static::$constraints = true;

        return $results;
    }