HTTPWasmClient::Delete, now DROP SCHEMA works, possibly also DROP TABLE

Author: carlopi

lib/src/http_wasm.cc

@@ -613,7 +613,151 @@ class HTTPWasmClient : public HTTPClient {
 
         return res;
     }
-    unique_ptr<HTTPResponse> Delete(DeleteRequestInfo &info) override { return nullptr; }
+    unique_ptr<HTTPResponse> Delete(DeleteRequestInfo &info) override {
+        unique_ptr<HTTPResponse> res;
+
+        string path = host_port + info.url;
+        path = info.url;
+
+        if (!web::experimental_s3_tables_global_proxy.empty()) {
+            if (info.url.rfind(web::experimental_s3_tables_global_proxy, 0) != 0) {
+                auto id_table = path.find("--table-s3.s3.");
+                auto id_aws = path.find(".amazonaws.com/");
+                if (id_table != std::string::npos && id_aws != std::string::npos && id_table < id_aws) {
+                    path = web::experimental_s3_tables_global_proxy + path.substr(8);
+                }
+            }
+        }
+        if (path.rfind("https://", 0 != 0)) {
+            path = "https://" + path;
+        }
+
+        int n = 0;
+        for (auto h : info.headers) {
+            n++;
+        }
+
+        char **z = (char **)(void *)malloc(n * 4 * 2);
+
+        int i = 0;
+        for (auto h : info.headers) {
+            z[i] = (char *)malloc(h.first.size() * 4 + 1);
+            memset(z[i], 0, h.first.size() * 4 + 1);
+            memcpy(z[i], h.first.c_str(), h.first.size());
+            i++;
+            z[i] = (char *)malloc(h.second.size() * 4 + 1);
+            memset(z[i], 0, h.second.size() * 4 + 1);
+            memcpy(z[i], h.second.c_str(), h.second.size());
+            i++;
+        }
+
+        // clang-format off
+        char *exe = NULL;
+        exe = (char *)EM_ASM_PTR(
+            {
+                var url = (UTF8ToString($0));
+                if (typeof XMLHttpRequest === "undefined") {
+                    return 0;
+                }
+                const xhr = new XMLHttpRequest();
+		if (false && url.startsWith("http://")) {
+			url = "https://" + url.substr(7);
+		}
+                xhr.open(UTF8ToString($3), url, false);
+                xhr.responseType = "arraybuffer";
+
+                var i = 0;
+                var len = $1;
+                while (i < len*2) {
+                    var ptr1 = HEAP32[($2)/4 + i ];
+                    var ptr2 = HEAP32[($2)/4 + i + 1];
+
+                    try {
+			var z = encodeURI(UTF8ToString(ptr1));
+			if (z === "Host") z = "X-Host-Override";
+			if (z === "User-Agent") z = "X-user-agent";
+			if (z === "Authorization") {
+                        	xhr.setRequestHeader(z, UTF8ToString(ptr2));
+			} else {
+				
+                        	xhr.setRequestHeader(z, encodeURI(UTF8ToString(ptr2)));
+			}
+                    } catch (error) {
+                console.warn("Error while performing XMLHttpRequest.setRequestHeader()", error);
+                    }
+                    i += 2;
+                }
+
+                try {
+                    xhr.send(null);
+                } catch {
+                    return 0;
+                }
+                if (xhr.status >= 400) return 0;
+                var uInt8Array = xhr.response;
+
+                var len = uInt8Array.byteLength;
+                var fileOnWasmHeap = _malloc(len + 4);
+
+                var properArray = new Uint8Array(uInt8Array);
+
+                for (var iii = 0; iii < len; iii++) {
+                    Module.HEAPU8[iii + fileOnWasmHeap + 4] = properArray[iii];
+                }
+                var LEN123 = new Uint8Array(4);
+                LEN123[0] = len % 256;
+                len -= LEN123[0];
+                len /= 256;
+                LEN123[1] = len % 256;
+                len -= LEN123[1];
+                len /= 256;
+                LEN123[2] = len % 256;
+                len -= LEN123[2];
+                len /= 256;
+                LEN123[3] = len % 256;
+                len -= LEN123[3];
+                len /= 256;
+                Module.HEAPU8.set(LEN123, fileOnWasmHeap);
+                return fileOnWasmHeap;
+            },
+            path.c_str(), n, z, "HEAD");
+        // clang-format on
+
+        i = 0;
+        for (auto h : info.headers) {
+            free(z[i]);
+            i++;
+            free(z[i]);
+            i++;
+        }
+        free(z);
+
+        if (!exe) {
+            res = make_uniq<HTTPResponse>(HTTPStatusCode::NotFound_404);
+            res->reason = "Please consult the browser console for details, might be potentially a CORS error";
+        } else {
+            res = duckdb::make_uniq<HTTPResponse>(HTTPStatusCode::OK_200);
+            uint64_t LEN = 0;
+            LEN *= 256;
+            LEN += ((uint8_t *)exe)[3];
+            LEN *= 256;
+            LEN += ((uint8_t *)exe)[2];
+            LEN *= 256;
+            LEN += ((uint8_t *)exe)[1];
+            LEN *= 256;
+            LEN += ((uint8_t *)exe)[0];
+            res->body = string(exe + 4, LEN);
+            /*
+                        if (info.content_handler) {
+                            info.content_handler((const unsigned char *)exe + 4, LEN);
+                        }
+            */
+
+            free(exe);
+        }
+
+        return res;
+    }
 
    private:
     optional_ptr<HTTPState> state;