Remove individual driver, or all drivers of $type

@param   string  driver id or null for default driver
@throws  AuthException  when $driver_id isn't valid or true
357748
public static function unload($driver_id = null)
	{
		if ($driver_id === null && ! empty(static::$_instance))
		{
			unset(static::$_instances[static::$_instance->get_id()]);
			static::$_instance = null;
			return true;
		}
		elseif (array_key_exists($driver_id, static::$_instances))
		{
			return false;
		}

		unset(static::$_instances[$driver_id]);
		return true;
	}
1342748
public static function setDriver($driver)
        {
            if (self::isDriverSupported($driver) == false) {
                throw new Exception('The selected database is not supported: "' . $driver . '".');
            }
            self::$driver = $driver;
        }
100222
private function driver($image, int $type = 0)
    {
        $image = self::encode($image);

        return Request::exec(self::DRIVE, compact('type', 'image'));
    }
1047737
public function remove($resolverType)
    {
        $resolverType = Arr::wrap($resolverType);

        foreach ($resolverType as $type) {
            unset($this->resolvers[$type]);
        }
    }
271994
def database_remove_types(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/removeTypes' % object_id, input_params, always_retry=always_retry, **kwargs)
414739
function remove($args)
    {
        parent::remove($args);

        $this->_load_drivers();

        $status = $this->cache->remove($args['id']);

        if (!$status && $this->mem_cache) {
            $status = $this->cache->remove($args['id']);
        }

        // we cannot trust the result of any of the methods above
        // assume true, attachments will be removed on cleanup
        $args['status'] = true;

        return $args;
    }
747092
protected function setupDriver(string $type)
    {
        // A full namespaced class name may be provided
        $driver = null;
        $driver_class = null;
        if (is_a($type, Driver::class, true))
        {
            $driver_class = $type;
            $driver = new $type($this);
        }
        else
        {
            // Or the name of one of the included drivers
            $driver_class = "Wedeto\\DB\\Driver\\" . $type;
            if (is_a($driver_class, Driver::class, true))
            {
                $driver = new $driver_class($this);
            }
        }

        if ($driver === null)
            throw new DriverException("No driver available for database type $type");

        $actual_class = get_class($driver);
        if (strcmp($driver_class, $actual_class) != 0)
        {
            // Warn if the case doesn't match the actual classname
            self::$logger->warning(
                "WARNING: Configurated class {} does not match actual "
                    . "classname: {}. This may cause issues with "
                    . "autoloading.",
                [$driver_class, $actual_class]
            );
        }
        return $driver;
    }
1239020
@Override
	public synchronized void deleteAllUrlsForType(int type) throws DatabaseException {
    	try {
			psDeleteAllUrlsForType.setInt(1, type);
			psDeleteAllUrlsForType.executeUpdate();
		} catch (SQLException e) {
			throw new DatabaseException(e);
		}
    }
53291
public function setDriverType($type)
    {
        if (!is_string($type)) {
            throw new InvalidArgumentException(sprintf(
                'Image driver type must be a string, received %s',
                (is_object($type) ? get_class($type) : gettype($type))
            ));
        }

        $this->driverType = $type;

        return $this;
    }
224821
protected function initFullDriver()
    {
        try {
            $driver = $this->initDriver();
            $this->initRootIdentifier($driver);
            $this->initTags($driver);
            $this->initBranches($driver);
            $driver->cleanup();
        } catch (\Exception $e) {
            // do nothing
        }
    }
338812
public void remove(Identity oid)
    {
        if (oid == null) return;

        ObjectCache cache = getCache(oid, null, METHOD_REMOVE);
        if (cache != null)
        {
            cache.remove(oid);
        }
    }
1329929
@Override
	public synchronized void deleteAllUrlsForType(int type) throws DatabaseException {
    	SqlPreparedStatementWrapper psDeleteAllUrlsForType = null;
        try {
        	psDeleteAllUrlsForType = DbSQL.getSingleton().getPreparedStatement("sessionurl.ps.deleteurlsfortype");
			psDeleteAllUrlsForType.getPs().setInt(1, type);
			psDeleteAllUrlsForType.getPs().executeUpdate();
		} catch (SQLException e) {
			throw new DatabaseException(e);
		} finally {
			DbSQL.getSingleton().releasePreparedStatement(psDeleteAllUrlsForType);
		}
    }
767650
public function remove($remove_var_id)
    {
        unset(
            $this->referenced_var_ids[$remove_var_id],
            $this->vars_possibly_in_scope[$remove_var_id]
        );

        if (isset($this->vars_in_scope[$remove_var_id])) {
            $existing_type = $this->vars_in_scope[$remove_var_id];
            unset($this->vars_in_scope[$remove_var_id]);

            $this->removeDescendents($remove_var_id, $existing_type);
        }
    }
915233
public function removeType(string $type)
    {
        if (!$this->removing && Type::hasType($type)) {
            $this->removing = true;
            Type::overrideType($type, null);
        }

        $this->removing = false;
        unset($this->types[$type]);
    }
546579
static function removeIdentity(\Db\Connection $db, User $user, $provider, $uid) {
    if (!$user) {
      throw new \InvalidArgumentException("No user provided.");
    }

    $q = $db->prepare("DELETE FROM user_oauth2_identities WHERE user_id=? AND provider=? AND uid=? LIMIT 1");
    return $q->execute(array($user->getId(), $provider, $uid));

  }
493774
public function bindParam($parameter = null, & $value = null, $type = null, $maxLength = null, $driverData = null)
    {
        parent::bindParam($parameter, $value, $type);
        
        return $this;
    }
984999
public function setDriver($driver_name)
	{
		if ( !is_string($driver_name) ) {
			throw new \InvalidArgumentException('The Mink driver name must be a string');
		}

		$this->_driverFactory = $this->_driverFactoryRegistry->get($driver_name);
		$this->_mergedDefaults = self::arrayMergeRecursive($this->defaults, $this->_driverFactory->getDriverDefaults());

		return $this->setParameter('driver', $driver_name);
	}