Examples with JQLParameterName com.abubusoft.kripton.processor.sqlite.grammars.jql.JQLChecker.JQLParameterName used on opensource projects

Example 1 with JQLParameterName

use of com.abubusoft.kripton.processor.sqlite.grammars.jql.JQLChecker.JQLParameterName in project kripton by xcesco.

the class SqlAnalyzer method execute.

/**
 * Extract from value string every placeholder ${}, replace it with ? and then convert every field typeName with column typeName. The result is a pair: the first value is the elaborated string. The second is the list of parameters associated to
 * ?. This second parameter is the list of parameters and replaced with ?.
 */
public void execute(Elements elementUtils, SQLiteModelMethod method, String sqlStatement) {
    SQLiteDaoDefinition daoDefinition = method.getParent();
    SQLiteEntity entity = daoDefinition.getEntity();
    usedMethodParameters = new HashSet<String>();
    paramNames = new ArrayList<String>();
    paramGetters = new ArrayList<String>();
    usedBeanPropertyNames = new ArrayList<String>();
    paramTypeNames = new ArrayList<TypeName>();
    // replace placeholder ${ } with ?
    {
        Matcher matcher = PARAMETER.matcher(sqlStatement);
        StringBuffer buffer = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(buffer, "?");
            paramNames.add(matcher.group(1));
        }
        matcher.appendTail(buffer);
        sqlStatement = buffer.toString();
    }
    // replace property typeName to column typeName
    {
        Matcher matcher = WORD.matcher(sqlStatement);
        StringBuffer buffer = new StringBuffer();
        while (matcher.find()) {
            SQLProperty property = entity.findPropertyByName(matcher.group(1));
            if (property != null) {
                matcher.appendReplacement(buffer, property.columnName);
            }
        }
        matcher.appendTail(buffer);
        sqlStatement = buffer.toString();
    }
    TypeName rawNameType;
    // analyze parametersName
    String effectiveName;
    for (String rawName : paramNames) {
        JQLParameterName pName = JQLParameterName.parse(rawName);
        if (!pName.isNested()) {
            effectiveName = method.findParameterNameByAlias(pName.getValue());
            rawNameType = method.findParameterTypeByAliasOrName(effectiveName);
            if (rawNameType == null) {
                throw new MethodParameterNotFoundException(method, effectiveName);
            }
            paramGetters.add(effectiveName);
            paramTypeNames.add(rawNameType);
            usedMethodParameters.add(effectiveName);
            usedBeanPropertyNames.add(null);
        } else {
            if (method.findParameterTypeByAliasOrName(pName.getBeanName()) == null) {
                throw new MethodParameterNotFoundException(method, pName.getBeanName());
            }
            if (TypeUtility.isEquals(method.findParameterTypeByAliasOrName(pName.getBeanName()), entity) && entity.contains(pName.getValue())) {
                // there are nested property invocation
                paramGetters.add(method.findParameterNameByAlias(pName.getBeanName()) + "." + getter(entity.findPropertyByName(pName.getValue())));
                usedBeanPropertyNames.add(pName.getValue());
                paramTypeNames.add(TypeUtility.typeName(entity.findPropertyByName(pName.getValue()).getElement().asType()));
                usedMethodParameters.add(method.findParameterNameByAlias(pName.getBeanName()));
            } else {
                throw (new PropertyInAnnotationNotFoundException(method, pName.getValue()));
            }
        }
    // } else {
    // throw (new PropertyInAnnotationNotFoundException(method, rawName));
    // }
    }
    this.sqlStatement = sqlStatement;
}

Example 2 with JQLParameterName

use of com.abubusoft.kripton.processor.sqlite.grammars.jql.JQLChecker.JQLParameterName in project kripton by xcesco.

the class SqlModifyBuilder method generateModifierForContentProvider.

/**
 * <p>
 * Generate update and delete used in content provider class.
 * </p>
 *
 * @param elementUtils
 * @param builder
 * @param method
 * @param updateResultType
 */
private static void generateModifierForContentProvider(Elements elementUtils, Builder builder, final SQLiteModelMethod method, ModifyType updateResultType) {
    final SQLiteDaoDefinition daoDefinition = method.getParent();
    final SQLiteEntity entity = daoDefinition.getEntity();
    final Set<String> columns = new LinkedHashSet<>();
    JQLChecker jqlChecker = JQLChecker.getInstance();
    // parameters extracted from query
    final One<String> whereStatement = new One<>();
    if (method.jql.isWhereConditions()) {
        // parameters extracted from query
        final One<Boolean> alreadyFoundWhereStatement = new One<>(false);
        // put in whereStatement value of where statement.
        jqlChecker.replaceVariableStatements(method, method.jql.value, new JQLReplaceVariableStatementListenerImpl() {

            @Override
            public String onWhere(String statement) {
                if (alreadyFoundWhereStatement.value0 == false) {
                    whereStatement.value0 = statement;
                    alreadyFoundWhereStatement.value0 = true;
                    return "";
                } else {
                    // DO NOTHING
                    return null;
                }
            }
        });
    }
    List<JQLPlaceHolder> placeHolders = jqlChecker.extractFromVariableStatement(method, whereStatement.value0);
    // remove placeholder for dynamic where, we are not interested here
    placeHolders = SqlBuilderHelper.removeDynamicPlaceHolder(placeHolders);
    checkContentProviderVarsAndArguments(method, placeHolders);
    // detect column used for content value
    jqlChecker.replace(method, method.jql, new JQLReplacerListenerImpl(method) {

        @Override
        public String onColumnNameToUpdate(String columnName) {
            SQLProperty tempProperty = entity.get(columnName);
            AssertKripton.assertTrueOrUnknownPropertyInJQLException(tempProperty != null, method, columnName);
            columns.add(tempProperty.columnName);
            return null;
        }
    });
    MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(method.contentProviderMethodName);
    // params
    methodBuilder.addParameter(ParameterSpec.builder(Uri.class, "uri").build());
    if (updateResultType == ModifyType.UPDATE_BEAN || updateResultType == ModifyType.UPDATE_RAW) {
        methodBuilder.addParameter(ParameterSpec.builder(ContentValues.class, "contentValues").build());
    }
    methodBuilder.addParameter(ParameterSpec.builder(String.class, "selection").build());
    methodBuilder.addParameter(ParameterSpec.builder(ArrayTypeName.of(String.class), "selectionArgs").build());
    methodBuilder.returns(Integer.TYPE);
    // retrieve content values
    if (updateResultType == ModifyType.UPDATE_BEAN || updateResultType == ModifyType.UPDATE_RAW) {
        methodBuilder.addStatement("$T _contentValues=contentValuesForContentProvider(contentValues)", KriptonContentValues.class);
    } else {
        methodBuilder.addStatement("$T _contentValues=contentValues()", KriptonContentValues.class);
    }
    SqlBuilderHelper.generateLogForContentProviderBeginning(method, methodBuilder);
    // query builder
    methodBuilder.addStatement("$T _sqlBuilder=sqlBuilder()", StringBuilder.class);
    generateInitForDynamicWhereVariables(method, methodBuilder, "selection", "selectionArgs");
    SqlBuilderHelper.generateWhereCondition(methodBuilder, method, false);
    int i = 0;
    // every controls was done in constructor of SQLiteModelMethod
    for (ContentUriPlaceHolder variable : method.contentProviderUriVariables) {
        AssertKripton.assertTrue(SqlBuilderHelper.validate(variable.value, placeHolders, i), "In '%s.%s' content provider URI path variables and variables in where conditions are different. If SQL uses parameters, they must be defined in URI path.", daoDefinition.getName(), method.getName());
        JQLParameterName paramName = JQLParameterName.parse(variable.value);
        SQLProperty entityProperty = entity.get(paramName.getValue());
        if (entityProperty != null) {
            methodBuilder.addCode("// Add parameter $L at path segment $L\n", variable.value, variable.pathSegmentIndex);
            // methodBuilder.addStatement("_sqlWhereParams.add(uri.getPathSegments().get($L))",
            // variable.pathSegmentIndex);
            methodBuilder.addStatement("_contentValues.addWhereArgs(uri.getPathSegments().get($L))", variable.pathSegmentIndex);
            AssertKripton.assertTrue(TypeUtility.isTypeIncludedIn(entityProperty.getPropertyType().getTypeName(), String.class, Long.class, Long.TYPE), "In '%s.%s' content provider URI path variables %s must be String of Long type", daoDefinition.getName(), method.getName(), entityProperty.getName());
        }
        i++;
    }
    if (method.hasDynamicWhereConditions() && method.hasDynamicWhereArgs()) {
        // ASSERT: only with dynamic where conditions
        methodBuilder.beginControlFlow("if ($T.hasText(_sqlDynamicWhere) && _sqlDynamicWhereArgs!=null)", StringUtils.class);
        if (method.hasDynamicWhereConditions()) {
            methodBuilder.beginControlFlow("for (String _arg: _sqlDynamicWhereArgs)");
            // methodBuilder.addStatement("_sqlWhereParams.add(_arg)");
            methodBuilder.addStatement("_contentValues.addWhereArgs(_arg)");
            methodBuilder.endControlFlow();
        }
        methodBuilder.endControlFlow();
    }
    // column checj
    switch(updateResultType) {
        case UPDATE_BEAN:
        case UPDATE_RAW:
            SqlBuilderHelper.generateColumnCheckSet(builder, method, columns);
            SqlBuilderHelper.forEachColumnInContentValue(methodBuilder, method, "_contentValues.values().keySet()", true, null);
            break;
        default:
            break;
    }
    // generate log section - BEGIN
    methodBuilder.addComment("log section BEGIN");
    methodBuilder.beginControlFlow("if (_context.isLogEnabled())");
    generateLogForModifiers(method, methodBuilder);
    if (method.jql.operationType == JQLType.UPDATE) {
        // generate log for content values
        SqlBuilderHelper.generateLogForContentValues(method, methodBuilder);
    }
    // log for where parames
    SqlBuilderHelper.generateLogForWhereParameters(method, methodBuilder);
    // generate log section - END
    methodBuilder.endControlFlow();
    methodBuilder.addComment("log section END");
    methodBuilder.addCode("\n// execute SQL\n");
    switch(updateResultType) {
        case DELETE_BEAN:
        case DELETE_RAW:
            methodBuilder.addStatement("int result = database().delete($S, _sqlWhereStatement, _contentValues.whereArgsAsArray())", daoDefinition.getEntity().getTableName());
            if (method.getParent().getParent().generateRx) {
                GenericSQLHelper.generateSubjectNext(methodBuilder, SubjectType.DELETE);
            }
            break;
        case UPDATE_BEAN:
        case UPDATE_RAW:
            if (method.jql.conflictAlgorithmType == ConflictAlgorithmType.NONE) {
                methodBuilder.addStatement("int result = database().update($S, _contentValues.values(), _sqlWhereStatement, _contentValues.whereArgsAsArray())", daoDefinition.getEntity().getTableName());
            } else {
                methodBuilder.addCode("// conflict algorithm $L\n", method.jql.conflictAlgorithmType);
                methodBuilder.addStatement("int result = database().updateWithOnConflict($S, _contentValues.values(), _sqlWhereStatement, _contentValues.whereArgsAsArray()), $L)", daoDefinition.getEntity().getTableName(), method.jql.conflictAlgorithmType.getConflictAlgorithm());
            }
            if (method.getParent().getParent().generateRx) {
                GenericSQLHelper.generateSubjectNext(methodBuilder, SubjectType.UPDATE);
            }
            break;
    }
    // support for livedata
    if (daoDefinition.hasLiveData()) {
        methodBuilder.addComment("support for livedata");
        methodBuilder.addStatement(BindDaoBuilder.METHOD_NAME_REGISTRY_EVENT + "(result)");
    }
    methodBuilder.addStatement("return result");
    // we add at last javadoc, because need info is built at last.
    SqlBuilderHelper.generateJavaDocForContentProvider(method, methodBuilder);
    methodBuilder.addJavadoc("@param uri $S\n", method.contentProviderUriTemplate.replace("*", "[*]"));
    switch(updateResultType) {
        case UPDATE_BEAN:
        case UPDATE_RAW:
            methodBuilder.addJavadoc("@param contentValues content values\n");
            break;
        default:
            break;
    }
    methodBuilder.addJavadoc("@param selection dynamic part of <code>where</code> statement $L\n", method.hasDynamicWhereConditions() ? "" : "<b>NOT USED</b>");
    methodBuilder.addJavadoc("@param selectionArgs arguments of dynamic part of <code>where</code> statement $L\n", method.hasDynamicWhereConditions() ? "" : "<b>NOT USED</b>");
    methodBuilder.addJavadoc("@return number of effected rows\n");
    builder.addMethod(methodBuilder.build());
}