Unfortunately, your code is destined to fail regardless of the changes below, but let me explain why you’re seeing the problem you encountered before explaining why this still wouldn’t work.

The Error

Your DB class isn’t a type of mysqli, but this can be fixed by changing class DB to:

class DB extends mysqli

Here’s a breakdown of what’s happening:

<?php

// Defines a new class, DB, which is type DB.
class DB {}

// Defines "db" as an instance of the DB class, still type DB.
define("db",new DB(DB_HOST, DB_USER, DB_PASS, DB_NAME));

// This is trying to pass "db" as the first argument to mysqli_query().
if (mysqli_query(db, $sql)) {}

The problem is that mysqli_query is expecting the following:

function mysqli_query(
    mysqli $mysql,
    string $query,
    int|null $result_mode = MYSQLI_STORE_RESULT
): bool|mysqli_result

As you can see, the first parameter expects type mysqli, whether instanced directly with new mysqli() or indirectly with extends mysqli. The fact that you’ve instanced a new mysqli inside of DB doesn’t make a difference, you could copy the entire mysqli class but if you name it DB it’s still going to be typed in that way without an extension.

Once you make this change, your argument should be accepted.

The Problem

The underlying issue is that your DB class still won’t be appropriate for executing mysqli class code.

If you take a look at the mysqli class docs, you’ll notice that your class isn’t appropriately designed to contain your connection information and will ultimately fail because the function you’re calling can’t access $conn. Your wrapper works for very basic use-cases to call the query() and clean() methods, but that’s all. It doesn’t actually inject the necessary information required for the parent mysqli class to function properly.

Technically, you could remedy this by exposing $conn with a getter:

<?php
class DB {
    // ...other stuff
    public function getConn() {
        return $this->conn;
    }
}

mysqli_query(db->getConn(), $sql);

Or by using the __toString() magic method which will always treat db as the connection when you aren’t calling other methods like db->query().

<?php
class DB {
    // ...other stuff
    public function __toString() {
        return $this->conn;
    }
}

mysqli_query(db, $sql);

However, this seems really impractical unless you have some reason to hide the rest of the mysqli functionality.

Wrappers

This would almost be appropriate for creating a database wrapper containing logic for interacting with functions like mysqli_query inside of its own class, but it doesn’t seem the be the goal you have in mind.

A wrapper is useful because it allows you to implement logic in one place. You’re using functions outside of this class requiring mysqli though, so it doesn’t actually aid you in this situation. However, a corrected example could be something like this:

<?php
class DB {
    // ...other stuff
    public function db_query($sql) {
        return mysqli_query($this->conn, $sql);
    }
}

// Now, if you change databases you can just edit db_query.
db->db_query($sql);

Child Classes

The correct way to build a class in this manner would be to inject your __construct arguments into the parent class, but since you’re overwriting the query() method to call $conn, this would also result in a broken instance of your database class.

An example of how you’d correctly build a child class would look something like this:

<?php
class DB extends mysqli {
    public function __construct($host, $user, $pass, $database, $port = 3306) {
        parent::__construct($host, $user, $pass, $database, $port);
    }

    // New custom methods go here.
}

// Now a fully functional mysqli child!
$db = new DB(DB_HOST, DB_USER, DB_PASS, DB_NAME);

My recommendation would be to just create a direct instance through $db = new mysqli() instead of going through any of these abstraction processes. Although abstracting classes this way has its uses, since you’re still in the learning stages I think it’s adding extra, unnecessary complexity.