class CreateRolePlan implements Plan {

    public static final String PASSWORD_PROPERTY_KEY = "password";
    public static final String JWT_PROPERTY_KEY = "jwt";


    private final AnalyzedCreateRole createRole;
    private final RoleManager roleManager;

    public CreateRolePlan(AnalyzedCreateRole createRole, RoleManager roleManager) {
        this.createRole = createRole;
        this.roleManager = roleManager;
    }

    @Override
    public StatementType type() {
        return StatementType.DDL;
    }

    @Override
    public void executeOrFail(DependencyCarrier dependencies,
                              PlannerContext plannerContext,
                              RowConsumer consumer,
                              Row params,
                              SubQueryResults subQueryResults) throws Exception {<FILL_FUNCTION_BODY>}

    public static Map<String, Object> parse(GenericProperties<Symbol> genericProperties,
                                               TransactionContext txnCtx,
                                               NodeContext nodeContext,
                                               Row params,
                                               SubQueryResults subQueryResults) {
        Function<? super Symbol, Object> eval = x -> SymbolEvaluator.evaluate(
            txnCtx,
            nodeContext,
            x,
            params,
            subQueryResults
        );
        Map<String, Object> parsedProperties = genericProperties.map(eval).properties();
        for (var property : parsedProperties.keySet()) {
            if (PASSWORD_PROPERTY_KEY.equals(property) == false && JWT_PROPERTY_KEY.equals(property) == false) {
                throw new IllegalArgumentException(
                    String.format(Locale.ENGLISH, "\"%s\" is not a valid user property", property));
            }
        }
        return parsedProperties;
    }
}


        Map<String, Object> properties = parse(
            createRole.properties(),
            plannerContext.transactionContext(),
            plannerContext.nodeContext(),
            params,
            subQueryResults
        );
        SecureHash newPassword = UserActions.generateSecureHash(properties);

        if (createRole.isUser() == false && newPassword != null) {
            throw new UnsupportedOperationException("Creating a ROLE with a password is not allowed, " +
                                                    "use CREATE USER instead");
        }

        JwtProperties jwtProperties = JwtProperties.fromMap(Maps.get(properties, JWT_PROPERTY_KEY));

        roleManager.createRole(createRole.roleName(), createRole.isUser(), newPassword, jwtProperties)
            .whenComplete(new OneRowActionListener<>(consumer, rCount -> new Row1(rCount == null ? -1 : rCount)));
    
<no_super_class>