How to use conditions within a single CONSTRUCT query in SPARQL

I would like to programmatically construct an rdf (actually owl) graph given some data. The data can be of different 'types' and, depending on the type, the graph should have a different structure. The data is stored in an Excel spredsheet with multiple sheets (one sheet per 'type').

I hoped, naively, to use OntoText Refine to read all sheets at once and use a single CONSTRUCT/INSERT sparql query to build the graph, hoping that, if a column used in the binding operands were missing from a sheet, the relative triples in the CONSTRUCT scope would have been somehow skipped. (Of course) this is does not work (maybe because the null values are not always triple subjects, I'm not sure).

Then, another possibility I envisioned is to write a script in some language that could read the Excel file and, for each sheet, run a different CONSTRUCT query. This would work, but I would prefer to use a single CONSTRUCT query for simplicity/portability.

Therefore, I would like to write a query such as the following, where the IF...THEN... part is pseudocode to indicate my intention and preferred_label, etc. are sheets columns:

BASE <http://www.mybaseprefix.com/>
PREFIX mapper: <http://www.ontotext.com/mapper/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

CONSTRUCT 
{

    ## constant part
    ?key_iri skos:prefLabel ?preferred_label


    ## variable part
    # case 1
    IF (NOT(?input = 'Input is null')) THEN {
        ?key_iri rdfs:subClassOf [ a owl:Restriction ;
        			owl:onProperty <has_input> ;
             			owl:allValuesFrom ?input ]. }
    
    # case 2
    IF (NOT(?output = 'Output is null')) THEN {
        ?key_iri rdfs:subClassOf [ a owl:Restriction ;
        		        owl:onProperty <has_output> ;
             			owl:allValuesFrom ?output ]. }
    
    } 
WHERE {
    SERVICE <http://localhost:7333/repositories/ontorefine:my_ontotext_refine_project> {
        ## key and key preferred label
        (?row_index "toTitlecase(replace(trim(cells[\"preferred_label\"].value), ' ', '_'))") mapper:grel ?key_grel .
        BIND(IRI(mapper:encode_iri(?key_grel)) as ?key_iri)
        BIND(STRLANG(?spreadsheet_column_containing_preferred_label, "it") as ?preferred_label)

       
        ## object properties which can be sometimes null
        (?row_index "toTitlecase(replace(if(cells[\"input\"].value == null, 'Input is null', cells[\"input\"].value), ' ', '_'))") mapper:grel ?input_grel .
        BIND(IRI(mapper:encode_iri(?input_grel)) as ?input)
        (?row_index "toTitlecase(replace(if(cells[\"output\"].value == null, 'Output is null', cells[\"output\"].value), ' ', '_'))") mapper:grel ?output_grel .
        BIND(IRI(mapper:encode_iri(?output_grel)) as ?output)
        
    }
}

But I am not sure how (and if) is possible to do this.
I understand that I can use OPTIONAL pattern matching or IF functions in the WHERE scope (like answers in similar stackoverflow questions suggested), but I want to build different graphs given a condition not the same graph if a certain condition occurs.

I would gladly accept suggestions. Many thanks.

After some tinkering, I realized that my problem can be answered, albeit partially, by using OPTIONAL clauses in the WHERE scope.
First of all, it is necessary to remove the syntactical sugar of the square and round brackets.

E.g. from

 ?key_iri rdfs:subClassOf [ a owl:Restriction ;
                    owl:onProperty <has_input> ;
                    owl:allValuesFrom ?input ]

to

 ?key_iri rdfs:subClassOf ?new_blank_node .
 ?new_blank_node a owl:Restriction ;
                   owl:onProperty <has_input> ;
                   owl:allValuesFrom ?input .

And, similarly, if rdf lists are present with round brackets, they must be replaced using explicitly blank nodes.

Then, one can add in the WHERE scope something like:

OPTIONAL {  FILTER(?input != 'Input is null')
      			BIND(BNODE() as ?new_blank_node)}

This is not ideal, though, as complex OWL patterns may require lengthy effort and more complex filters as well as several blank nodes within the OPTIONAL scopes to reach the desired behaviour.

I select this answer hoping that It may help somebody else in the future.
Regards.