You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: cli.rs
    path of file: ./repos/prisma-engines/query-engine/query-engine/src
    
    the code of the file until where you have to start completion: use crate::{
    context::PrismaContext,
    features::{EnabledFeatures, Feature},
    opt::{CliOpt, PrismaOpt, Subcommand},
    PrismaResult,
};
use query_core::{protocol::EngineProtocol, schema};
use request_handlers::{dmmf, RequestBody, RequestHandler};
use std::{env, sync::Arc};

pub struct ExecuteRequest {
    query: String,
    schema: psl::ValidatedSchema,
    enable_raw_queries: bool,
    engine_p
    
    async fn execute_request(request: ExecuteRequest) -> PrismaResult<()> {
        let decoded = base64::decode(&request.query)?;
        let decoded_request = String::from_utf8(decoded)?;

        request
            .schema
            .configuration
            .validate_that_one_datasource_is_provided()?;

        let mut features = EnabledFeatures::default();
        if request.enable_raw_queries {
            features |= Feature::RawQueries
        }
        let cx = PrismaContext::new(request.schema, request.engine_protocol, features, None).await?;

        let cx = Arc::new(cx);

        let handler = RequestHandler::new(cx.executor(), cx.query_schema(), cx.engine_protocol());

        let body = RequestBody::try_from_str(&decoded_request, cx.engine_protocol())?;

        let res = handler.handle(body, None, None).await;
        let res = serde_json::to_string(&res).unwrap();

        let encoded_response = base64::encode(res);
        println!("Response: {encoded_response}"); // reason for prefix is explained in TestServer.scala

        Ok(())
    }