All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • io.nosqlbench.engine.api.activityconfig.rawyaml.StatementsOwner Maven / Gradle / Ivy

    /*
 * Copyright (c) 2022 nosqlbench
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.nosqlbench.engine.api.activityconfig.rawyaml;

import io.nosqlbench.api.errors.BasicError;

import java.util.*;

public class StatementsOwner extends RawStmtFields {

    private final static List stmtsFieldNames = List.of("op","ops","operation","statement","statements");

    private List rawStmtDefs = new ArrayList<>();

    public StatementsOwner() {
    }

    public List getRawStmtDefs() {
        return rawStmtDefs;
    }

    public void setRawStmtDefs(List rawStmtDefs) {
        this.rawStmtDefs = rawStmtDefs;
    }

    public void setFieldsByReflection(Map propsmap) {

        // New change
        super.setFieldsByReflection(propsmap);

        HashSet found = new HashSet<>();
        for (String fname : stmtsFieldNames) {
            if (propsmap.containsKey(fname)) {
                found.add(fname);
            }
        }
        if (found.size()>1) {
            throw new BasicError("You used " + found + " as an op name, but only one of these is allowed.");
        }
        if (found.size()==1) {
            Object stmtsFieldValue = propsmap.remove(found.iterator().next());
            setStatementsFieldByType(stmtsFieldValue);
        }

        super.setFieldsByReflection(propsmap);
    }

    @SuppressWarnings("unchecked")
    public void setStatementsFieldByType(Object object) {
        if (object instanceof List) {
            List stmtList = (List) object;
            List defs = new ArrayList<>(stmtList.size());
            for (int i = 0; i < stmtList.size(); i++) {
                String defaultName = "stmt" + (i + 1);
                Object o = stmtList.get(i);
                if (o instanceof String) {
                    defs.add(new RawStmtDef(defaultName, (String) o));
                } else if (o instanceof Map) {
                    RawStmtDef def = new RawStmtDef(defaultName, (Map) o);
                    defs.add(def);
                } else {
                    throw new RuntimeException("Can not construct stmt def from object type:" + o.getClass());
                }
            }
            this.setRawStmtDefs(defs);
        } else if (object instanceof Map) {
            Map map = (Map) object;
            List> itemizedMaps = new ArrayList<>();
            for (Map.Entry entries : map.entrySet()) {
                Object value = entries.getValue();
                if (value instanceof List listval) {
                    Map stmtDetails = new LinkedHashMap<>() {{
                        put("name",entries.getKey());
                        put("stmt", (List) listval);
                    }};
                    itemizedMaps.add(stmtDetails);
                } else if (value instanceof LinkedHashMap vmap) {
                    LinkedHashMap cp = new LinkedHashMap(vmap);
                    vmap.clear();
                    vmap.put("name", entries.getKey());
                    vmap.putAll(cp);
                    itemizedMaps.add(vmap);
                } else if (value instanceof String string) {
                    Map stmtDetails = new LinkedHashMap<>() {{
                        put("name", entries.getKey());
                        put("stmt", string);
                    }};
                    itemizedMaps.add(stmtDetails);
                } else {
                    throw new RuntimeException("Unknown inner value type on map-based statement definition: name:'" + entries.getKey() + "', type:'" +
                    entries.getValue().getClass() + "', only maps and strings are recognized.");
                }
            }
            setStatementsFieldByType(itemizedMaps);
        } else if (object instanceof String) {
            setStatementsFieldByType(Map.of("stmt1", (String) object));
        } else {
            throw new RuntimeException("Unknown object type: " + object.getClass());
        }
    }

}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy