Get the driver/connection/store from the managers

@param $alias
@return array|bool|string
960972
public function getDriver($alias)
    {
        try {
            if ($alias == "Auth") {
                $driver = \Auth::driver();
            } elseif ($alias == "DB") {
                $driver = \DB::connection();
            } elseif ($alias == "Cache") {
                $driver = get_class(\Cache::driver());
                $store = get_class(\Cache::getStore());
                return array($driver, $store);
            } elseif ($alias == "Queue") {
                $driver = \Queue::connection();
            } else {
                return false;
            }

            return get_class($driver);
        } catch (\Exception $e) {
            $this->error("Could not determine driver/connection for $alias.");
            return false;
        }
    }
309550
function getAlias( $alias ) {

        return isset( $this->aliases[ $alias ] ) ? $this->aliases[ $alias ] : $alias;

    }
1265515
public static function getConnection($driver)
    {
        $driver = strtolower($driver);

        if (empty(static::$connections[$driver])) {
            return null;
        }

        return static::$connections[$driver];
    }
1154300
public function getAliasNamespace($alias)
    {
        foreach ($this->getManagerNames() as $name) {
            try {
                return $this->getManager($name)->getConfiguration()->getEntityNamespace($alias);
            } catch (ORMException $e) {
            }
        }

        throw ORMException::unknownEntityNamespace($alias);
    }
88757
public function getType($alias)
    {
        if (array_key_exists($alias, $this->types)) {
            return $this->types[$alias];
        }

        return false;
    }
352629
public function get($alias)
    {
        if (!isset($this->registered[$alias]))
            return false;
        
        // Does an instance exist for this alias?
        if (isset($this->instance[$alias]) && is_object($this->instance[$alias]))
            return $this->instance[$alias];
        
        // Execute the Closure to get the first instance
        $this->instance[$alias] = $this->registered[$alias]($this);
        if (!is_object($this->instance[$alias]))
            throw new Exception('The alias "' . $alias . '" does not return an object.');
        
        return $this->instance[$alias];
    }
1008846
public function getConfiguration($alias)
    {
        if (array_key_exists($alias, $this->searchConfigurations)) {
            return $this->searchConfigurations[$alias];
        }

        return null;
    }
177248
public function getDomain($alias) {
		if (isset($this->aliases[$alias])) {
			return $this->aliases[$alias];
		}
		return $alias;
	}
826977
public function get($alias)
    {
        if (false === $this->has($alias)) {
            throw new DataSetTransformerNotFoundException($alias);
        }

        return $this->items[$alias];
    }
554445
public function getSubqueryByAlias($alias)
    {
        return $this->hasSubqueryAlias($alias) ? $this->getExpression($this->getHash($alias)) : null;
    }
883483
final public function getIndex(string $alias): ?GlobalSecondaryIndex
    {
        $this->loadIndexes();
        return $this->gsi[$alias] ?? null;
    }
213247
public function getTableFromAlias(string $alias) : \Dms\Core\Persistence\Db\Schema\Table
    {
        if ($this->alias === $alias) {
            return $this->table;
        }

        foreach ($this->joins as $join) {
            if ($join->getAlias() === $alias) {
                return $join->getTable();
            }
        }

        throw InvalidArgumentException::format(
            'Invalid alias supplied to %s: expecting one of (%s), \'%s\' given',
            __METHOD__, Debug::formatValues($this->getAliases()), $alias
        );
    }
1278445
public function load($alias)
    {
        if (static::$facadeNamespace && strpos($alias, static::$facadeNamespace) === 0) {
            $this->loadFacade($alias);

            return true;
        }

        if (isset($this->aliases[$alias])) {
            return class_alias($this->aliases[$alias], $alias);
        }
    }
419796
public function getTable($alias)
    {
        // has factory ?
        if (isset($this->_table_factory[$alias])) return $this->_table_factory[$alias];

        $class_name = $this->config->getNamingStrategy()->aliasToTableClassName($alias);
        foreach ($this->config->getModelDirs() as $dir) {
            $class_full_name  = sprintf('%s\\%s', $dir['namespace'], $class_name);
            if (class_exists($class_full_name)) {
                $table = new $class_full_name($this);
                if ($container = $this->raikiri()) {
                    $table->setContainer($container);
                }
                $this->_table_factory[$alias] = $table;
                return $table;
            }
        }
        throw new Exception\EntityTableNotFoundException('no such table. -> ' . $alias);
    }
1077950
public function get($alias)
    {
        return isset($this->services[$alias]) ? $this->services[$alias] : null;
    }
38008
protected function
	GetConnectionConfig($Alias) {
	/*//
	@return Nether\Database\Connection
	fetch the specified configuration. if none is found then it will throw an
	exception instead.
	//*/

		$Config = Nether\Option::Get('nether-database-connections');

		if(!array_key_exists($Alias,$Config))
		throw new Nether\Database\Error\InvalidConfig($Alias);

		if($Config[$Alias] instanceof Nether\Database\Connection)
		return $Config[$Alias];

		return new Nether\Database\Connection($Config[$Alias]);
	}
1281430
private function getRelatedBuilder($alias) {
        foreach($this->getRelatedBuilders() as $key => $builder) {
            if($alias == $key) {
                return $builder;
            }
        }
        return null;
    }