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

Example 1 with JQLReplaceVariableStatementListenerImpl

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

the class ModifyRawHelper method extractWhereConditions.

/**
 * @param updateMode
 * @param method
 * @return
 */
static String extractWhereConditions(boolean updateMode, SQLiteModelMethod method) {
    final One<String> whereCondition = new One<String>("");
    final One<Boolean> found = new One<Boolean>(null);
    JQLChecker.getInstance().replaceVariableStatements(method, method.jql.value, new JQLReplaceVariableStatementListenerImpl() {

        @Override
        public String onWhere(String statement) {
            if (found.value0 == null) {
                whereCondition.value0 = statement;
                found.value0 = true;
            }
            return null;
        }
    });
    return StringUtils.ifNotEmptyAppend(whereCondition.value0, " ");
}

Example 2 with JQLReplaceVariableStatementListenerImpl

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

the class SqlBuilderHelper method generateWhereCondition.

/**
 * <p>
 * Generate where management code.
 * </p>
 *
 * <h2>pre condition</h2>
 * <dl>
 * <dt>_sqlDynamicWhere</dt>
 * <dd>dynamic where</dd>
 * </dl>
 *
 * <h2>post conditions</h2>
 * <dl>
 * <dt>_sqlWhereParams</dt>
 * <dd>ArraList</dd>
 * <dt>_sqlWhereStatement</dt>
 * <dd>String</dd>
 * </dl>
 *
 * @param methodBuilder
 * @param method
 * @param jql
 * @param jqlChecker
 * @param sqlWhereStatement
 */
public static void generateWhereCondition(MethodSpec.Builder methodBuilder, final SQLiteModelMethod method, boolean sqlWhereParamsAlreadyDefined) {
    final JQL jql = method.jql;
    final JQLChecker jqlChecker = JQLChecker.getInstance();
    // we need always this
    if (!sqlWhereParamsAlreadyDefined) {
    // methodBuilder.addStatement("$T<String>
    // _sqlWhereParams=getWhereParamsArray()", ArrayList.class);
    }
    if (jql.isWhereConditions()) {
        // parameters extracted from query
        final One<String> whereStatement = new One<>();
        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;
                }
            }
        });
        methodBuilder.addCode("\n// manage WHERE arguments -- BEGIN\n");
        String sqlWhere = jqlChecker.replaceFromVariableStatement(method, whereStatement.value0, new JQLReplacerListenerImpl(method) {

            @Override
            public String onColumnName(String columnName) {
                SQLProperty tempProperty = currentEntity.get(columnName);
                AssertKripton.assertTrueOrUnknownPropertyInJQLException(tempProperty != null, method, columnName);
                return tempProperty.columnName;
            }

            @Override
            public String onDynamicSQL(JQLDynamicStatementType dynamicStatement) {
                return null;
            }

            @Override
            public String onBindParameter(String bindParameterName) {
                return "?";
            }
        });
        methodBuilder.addCode("\n// manage WHERE statement\n");
        String value = sqlWhere;
        String valueToReplace = jql.dynamicReplace.get(JQLDynamicStatementType.DYNAMIC_WHERE);
        if (method.jql.operationType == JQLType.SELECT) {
            // we have to include WHERE keywords
            if (jql.isStaticWhereConditions() && !jql.isDynamicWhereConditions()) {
                // case static statement and NO dynamic
                methodBuilder.addStatement("String _sqlWhereStatement=$S", value);
            } else if (jql.isStaticWhereConditions() && jql.isDynamicWhereConditions()) {
                methodBuilder.addStatement("String _sqlWhereStatement=$S+$T.ifNotEmptyAppend($L,\" $L \")", value.replace(valueToReplace, ""), StringUtils.class, "_sqlDynamicWhere", method.dynamicWherePrepend);
            } else if (!jql.isStaticWhereConditions() && jql.isDynamicWhereConditions()) {
                methodBuilder.addStatement("String _sqlWhereStatement=$T.ifNotEmptyAppend($L, \" $L \")", StringUtils.class, "_sqlDynamicWhere", JQLKeywords.WHERE_KEYWORD);
            }
        } else {
            // we DON'T have to include WHERE keywords
            value = value.replace(" " + JQLKeywords.WHERE_KEYWORD, "");
            if (jql.isStaticWhereConditions() && !jql.isDynamicWhereConditions()) {
                // case static statement and NO dynamic
                methodBuilder.addStatement("String _sqlWhereStatement=$S", value);
            } else if (jql.isStaticWhereConditions() && jql.isDynamicWhereConditions()) {
                methodBuilder.addStatement("String _sqlWhereStatement=$S+$T.ifNotEmptyAppend($L,\" $L \")", value.replace(valueToReplace, ""), StringUtils.class, "_sqlDynamicWhere", method.dynamicWherePrepend);
            } else if (!jql.isStaticWhereConditions() && jql.isDynamicWhereConditions()) {
                methodBuilder.addStatement("String _sqlWhereStatement=$T.ifNotEmptyAppend($L, \" \")", StringUtils.class, "_sqlDynamicWhere");
            }
        }
        methodBuilder.addStatement("_sqlBuilder.append($L)", "_sqlWhereStatement");
        methodBuilder.addCode("\n// manage WHERE arguments -- END\n");
    } else {
        // in every situation we need it
        methodBuilder.addStatement("String _sqlWhereStatement=\"\"");
    }
    // manage where arguments
    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();
    }
}

Example 3 with JQLReplaceVariableStatementListenerImpl

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

the class SqlSelectBuilder method generateSQL.

static SplittedSql generateSQL(final SQLiteModelMethod method, MethodSpec.Builder methodBuilder, final boolean replaceProjectedColumns) {
    JQLChecker jqlChecker = JQLChecker.getInstance();
    final SplittedSql splittedSql = new SplittedSql();
    String sql = convertJQL2SQL(method, false);
    // parameters extracted from JQL converted in SQL
    splittedSql.sqlBasic = jqlChecker.replaceVariableStatements(method, sql, new JQLReplaceVariableStatementListenerImpl() {

        @Override
        public String onWhere(String statement) {
            splittedSql.sqlWhereStatement = statement;
            return "";
        }

        @Override
        public String onOrderBy(String statement) {
            splittedSql.sqlOrderByStatement = statement;
            return "";
        }

        @Override
        public String onOffset(String statement) {
            splittedSql.sqlOffsetStatement = statement;
            return "";
        }

        @Override
        public String onLimit(String statement) {
            splittedSql.sqlLimitStatement = statement;
            return "";
        }

        @Override
        public String onHaving(String statement) {
            splittedSql.sqlHavingStatement = statement;
            return "";
        }

        @Override
        public String onGroup(String statement) {
            splittedSql.sqlGroupStatement = statement;
            return "";
        }

        @Override
        public String onProjectedColumns(String statement) {
            if (replaceProjectedColumns)
                return "%s";
            else
                return null;
        }
    });
    return splittedSql;
}

Example 4 with JQLReplaceVariableStatementListenerImpl

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

the class TestJqlChecker method testBindParametersFromVariableStatements.

@Test
public void testBindParametersFromVariableStatements() {
    final One<String> where = new One<>();
    final One<String> orderBy = new One<>();
    final One<String> limit = new One<>();
    final One<String> offset = new One<>();
    final One<String> group = new One<>();
    final One<String> having = new One<>();
    String sql = "SELECT id, parentId, birthCity, birthDay, value, name, surname FROM Person WHERE name like ${nameTemp} || '%' GROUP BY id HAVING id=2 ORDER BY id,  #{" + JQLDynamicStatementType.DYNAMIC_ORDER_BY + "} LIMIT #{" + JQLDynamicStatementType.DYNAMIC_PAGE_SIZE + "} OFFSET #{" + JQLDynamicStatementType.DYNAMIC_PAGE_OFFSET + "}";
    JQL jql = new JQL();
    jql.value = sql;
    JQLChecker checker = JQLChecker.getInstance();
    // verify sql
    checker.verify(dummyContext, jql);
    String finalSql = checker.replaceVariableStatements(dummyContext, jql.value, new JQLReplaceVariableStatementListenerImpl() {

        @Override
        public String onWhere(String whereStatement) {
            where.value0 = whereStatement;
            return "";
        }

        @Override
        public String onOrderBy(String orderByStatement) {
            orderBy.value0 = orderByStatement;
            return "";
        }

        @Override
        public String onLimit(String statement) {
            limit.value0 = statement;
            return "";
        }

        @Override
        public String onOffset(String statement) {
            offset.value0 = statement;
            return "";
        }

        @Override
        public String onGroup(String statement) {
            group.value0 = statement;
            return "";
        }

        @Override
        public String onHaving(String statement) {
            having.value0 = statement;
            return "";
        }

        @Override
        public String onProjectedColumns(String statement) {
            return null;
        }
    });
    log(where.value0);
    log(orderBy.value0);
    log(group.value0);
    log(having.value0);
    log(offset.value0);
    log(limit.value0);
    log(finalSql);
    // assertEquals(where, " id = ${dummy} and a=${dummy2}");
    {
        List<JQLPlaceHolder> list = checker.extractFromVariableStatement(new JQLContext() {

            @Override
            public String getContextDescription() {
                return "Test context";
            }
        }, where.value0);
        for (JQLPlaceHolder item : list) {
            log(item.value);
        }
        String replacedSql = checker.replaceFromVariableStatement(new JQLContext() {

            @Override
            public String getContextDescription() {
                return "Test context";
            }
        }, where.value0, new JQLReplacerListenerImpl(null) {

            @Override
            public String onDynamicSQL(JQLDynamicStatementType dynamicStatement) {
                return "*";
            }

            @Override
            public String onBindParameter(String bindParameterName) {
                return "?";
            }

            @Override
            public String onColumnFullyQualifiedName(String tableName, String columnName) {
                // TODO Auto-generated method stub
                return null;
            }
        });
        log(replacedSql);
    }
}

Example 5 with JQLReplaceVariableStatementListenerImpl

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

the class AbstractSelectCodeGenerator method generateCommonPart.

public void generateCommonPart(SQLiteModelMethod method, TypeSpec.Builder classBuilder, MethodSpec.Builder methodBuilder, Set<JQLProjection> fieldList, boolean mapFields, GenerationType generationType, TypeName forcedReturnType, JavadocPart... javadocParts) {
    SQLiteDaoDefinition daoDefinition = method.getParent();
    SQLiteEntity entity = daoDefinition.getEntity();
    // if true, field must be associate to ben attributes
    // TypeName returnType = method.getReturnClass();
    TypeName returnTypeName = forcedReturnType;
    if (returnTypeName == null) {
        returnTypeName = method.getReturnClass();
    }
    ModelAnnotation annotation = method.getAnnotation(BindSqlSelect.class);
    // parameters
    List<String> paramNames = new ArrayList<String>();
    List<String> paramGetters = new ArrayList<String>();
    List<TypeName> paramTypeNames = new ArrayList<TypeName>();
    List<String> usedBeanPropertyNames = new ArrayList<>();
    // used method parameters
    Set<String> usedMethodParameters = new HashSet<String>();
    final One<String> whereJQL = new One<>("");
    final One<String> havingJQL = new One<>("");
    final One<String> groupJQL = new One<>("");
    final One<String> orderJQL = new One<>("");
    // extract parts of jql statement
    JQLChecker.getInstance().replaceVariableStatements(method, method.jql.value, new JQLReplaceVariableStatementListenerImpl() {

        @Override
        public String onWhere(String statement) {
            whereJQL.value0 = statement;
            return null;
        }

        @Override
        public String onOrderBy(String statement) {
            orderJQL.value0 = statement;
            return null;
        }

        @Override
        public String onHaving(String statement) {
            havingJQL.value0 = statement;
            return null;
        }

        @Override
        public String onGroup(String statement) {
            groupJQL.value0 = statement;
            return null;
        }
    });
    SqlAnalyzer analyzer = new SqlAnalyzer();
    // String whereSQL =
    // annotation.getAttribute(AnnotationAttributeType.WHERE);
    analyzer.execute(BaseProcessor.elementUtils, method, whereJQL.value0);
    paramGetters.addAll(analyzer.getParamGetters());
    paramNames.addAll(analyzer.getParamNames());
    paramTypeNames.addAll(analyzer.getParamTypeNames());
    usedBeanPropertyNames.addAll(analyzer.getUsedBeanPropertyNames());
    usedMethodParameters.addAll(analyzer.getUsedMethodParameters());
    // String havingSQL =
    // annotation.getAttribute(AnnotationAttributeType.HAVING);
    analyzer.execute(BaseProcessor.elementUtils, method, havingJQL.value0);
    paramGetters.addAll(analyzer.getParamGetters());
    paramNames.addAll(analyzer.getParamNames());
    paramTypeNames.addAll(analyzer.getParamTypeNames());
    usedBeanPropertyNames.addAll(analyzer.getUsedBeanPropertyNames());
    usedMethodParameters.addAll(analyzer.getUsedMethodParameters());
    // String groupBySQL =
    // annotation.getAttribute(AnnotationAttributeType.GROUP_BY);
    analyzer.execute(BaseProcessor.elementUtils, method, groupJQL.value0);
    paramGetters.addAll(analyzer.getParamGetters());
    paramNames.addAll(analyzer.getParamNames());
    paramTypeNames.addAll(analyzer.getParamTypeNames());
    usedBeanPropertyNames.addAll(analyzer.getUsedBeanPropertyNames());
    usedMethodParameters.addAll(analyzer.getUsedMethodParameters());
    // String orderBySQL =
    // annotation.getAttribute(AnnotationAttributeType.ORDER_BY);
    analyzer.execute(BaseProcessor.elementUtils, method, orderJQL.value0);
    paramGetters.addAll(analyzer.getParamGetters());
    paramNames.addAll(analyzer.getParamNames());
    paramTypeNames.addAll(analyzer.getParamTypeNames());
    usedBeanPropertyNames.addAll(analyzer.getUsedBeanPropertyNames());
    usedMethodParameters.addAll(analyzer.getUsedMethodParameters());
    // add as used parameter dynamic components too
    if (method.hasDynamicWhereConditions()) {
        AssertKripton.assertTrueOrInvalidMethodSignException(!usedMethodParameters.contains(method.dynamicWhereParameterName), method, " parameter %s is used like SQL parameter and dynamic WHERE condition.", method.dynamicOrderByParameterName);
        usedMethodParameters.add(method.dynamicWhereParameterName);
        if (method.hasDynamicWhereArgs()) {
            AssertKripton.assertTrueOrInvalidMethodSignException(!usedMethodParameters.contains(method.dynamicWhereArgsParameterName), method, " parameter %s is used like SQL parameter and dynamic WHERE ARGS condition.", method.dynamicWhereArgsParameterName);
            usedMethodParameters.add(method.dynamicWhereArgsParameterName);
        }
    }
    if (method.hasDynamicOrderByConditions()) {
        AssertKripton.assertTrueOrInvalidMethodSignException(!usedMethodParameters.contains(method.dynamicOrderByParameterName), method, " parameter %s is used like SQL parameter and dynamic ORDER BY condition.", method.dynamicOrderByParameterName);
        usedMethodParameters.add(method.dynamicOrderByParameterName);
    }
    if (method.hasDynamicPageSizeConditions()) {
        AssertKripton.assertTrueOrInvalidMethodSignException(!usedMethodParameters.contains(method.dynamicPageSizeName), method, " parameter %s is used like SQL parameter and dynamic page size of LIMIT condition.", method.dynamicPageSizeName);
        usedMethodParameters.add(method.dynamicPageSizeName);
    }
    // generate method signature
    if (generationType.generateMethodSign) {
        generateMethodSignature(method, methodBuilder, returnTypeName);
    }
    // generate javadoc
    JavadocUtility.generateJavaDocForSelect(methodBuilder, paramNames, method, annotation, fieldList, selectType, javadocParts);
    if (generationType.generateMethodContent) {
        SplittedSql splittedSql = SqlSelectBuilder.generateSQL(method, methodBuilder, false);
        // retrieve content values
        methodBuilder.addStatement("$T _contentValues=contentValues()", KriptonContentValues.class);
        if (method.hasDynamicParts()) {
            generateSQLBuild(method, methodBuilder, splittedSql);
            methodBuilder.addStatement("String _sql=_sqlBuilder.toString()");
        } else {
            String sqlName = CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, method.buildSQLName());
            String sql = SqlSelectBuilder.convertJQL2SQL(method, true);
            classBuilder.addField(FieldSpec.builder(String.class, sqlName, Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL).initializer("$S", sql).build());
            methodBuilder.addComment("query SQL is statically defined");
            methodBuilder.addStatement("String _sql=$L", sqlName);
        }
        // build where condition (common for every type of select)
        StringBuilder logArgsBuffer = new StringBuilder();
        methodBuilder.addComment("add where arguments");
        {
            String separator = "";
            TypeName paramTypeName;
            // String paramName;
            boolean nullable;
            int i = 0;
            boolean rawParameters;
            String beanName = null;
            beanName = method.findEntityProperty();
            for (String item : paramGetters) {
                rawParameters = paramNames.get(i).indexOf(".") == -1;
                methodBuilder.addCode("_contentValues.addWhereArgs(");
                logArgsBuffer.append(separator + "%s");
                paramTypeName = paramTypeNames.get(i);
                // code for query arguments
                nullable = TypeUtility.isNullable(paramTypeName);
                if (rawParameters) {
                    if (nullable && !method.hasAdapterForParam(item)) {
                        methodBuilder.addCode("($L==null?\"\":", item);
                    }
                    // check for string conversion
                    TypeUtility.beginStringConversion(methodBuilder, paramTypeName);
                    SQLTransformer.javaMethodParam2WhereConditions(methodBuilder, method, item, paramTypeName);
                    // check for string conversion
                    TypeUtility.endStringConversion(methodBuilder, paramTypeName);
                    if (nullable && !method.hasAdapterForParam(item)) {
                        methodBuilder.addCode(")");
                    }
                } else {
                    // eventually we take associated property
                    SQLProperty property = usedBeanPropertyNames.get(i) == null ? null : entity.get(usedBeanPropertyNames.get(i));
                    if (nullable && !(property != null) && !method.hasAdapterForParam(item)) {
                        methodBuilder.addCode("($L==null?\"\":", item);
                    }
                    // check for string conversion
                    TypeUtility.beginStringConversion(methodBuilder, paramTypeName);
                    // if (property != null) {
                    // SQLTransformer.javaProperty2WhereCondition(methodBuilder,
                    // method, item, paramTypeName, property);
                    // } else {
                    SQLTransformer.javaProperty2WhereCondition(methodBuilder, method, beanName, paramTypeName, property);
                    // }
                    // check for string conversion
                    TypeUtility.endStringConversion(methodBuilder, paramTypeName);
                    if (nullable && !(property != null) && !method.hasAdapterForParam(item)) {
                        methodBuilder.addCode(")");
                    }
                }
                separator = ", ";
                i++;
                methodBuilder.addCode(");\n");
            }
        }
        methodBuilder.addStatement("String[] _sqlArgs=_contentValues.whereArgsAsArray()");
        if (daoDefinition.isLogEnabled()) {
            // generate log section - BEGIN
            methodBuilder.addComment("log section BEGIN");
            methodBuilder.beginControlFlow("if (_context.isLogEnabled())");
            // manage log
            methodBuilder.addComment("manage log");
            methodBuilder.addStatement("$T.info(_sql)", Logger.class);
            // log for where parames
            SqlBuilderHelper.generateLogForWhereParameters(method, methodBuilder);
            // generate log section - END
            methodBuilder.endControlFlow();
            methodBuilder.addComment("log section END");
        }
        if (generationType.generateCloseableCursor) {
            methodBuilder.beginControlFlow("try ($T _cursor = database().rawQuery(_sql, _sqlArgs))", Cursor.class);
        } else {
            methodBuilder.addStatement("$T _cursor = database().rawQuery(_sql, _sqlArgs)", Cursor.class);
        }
        if (daoDefinition.isLogEnabled()) {
            // generate log section - BEGIN
            methodBuilder.addComment("log section BEGIN");
            methodBuilder.beginControlFlow("if (_context.isLogEnabled())");
            methodBuilder.addCode("$T.info(\"Rows found: %s\",_cursor.getCount());\n", Logger.class);
            // generate log section - END
            methodBuilder.endControlFlow();
            methodBuilder.addComment("log section END");
        }
        switch(selectType) {
            case LISTENER_CURSOR:
                {
                    ClassName readCursorListenerToExclude = ClassName.get(OnReadCursorListener.class);
                    checkUnusedParameters(method, usedMethodParameters, readCursorListenerToExclude);
                }
                break;
            case LISTENER_BEAN:
                {
                    ParameterizedTypeName readBeanListenerToExclude = ParameterizedTypeName.get(ClassName.get(OnReadBeanListener.class), TypeName.get(entity.getElement().asType()));
                    checkUnusedParameters(method, usedMethodParameters, readBeanListenerToExclude);
                }
                break;
            default:
                checkUnusedParameters(method, usedMethodParameters, null);
                break;
        }
    }
}