use of com.abubusoft.kripton.common.One in project kripton by xcesco.
the class SqlBuilderHelper method orderContentValues.
public static List<Pair<String, TypeName>> orderContentValues(final SQLiteModelMethod method, final List<Pair<String, TypeName>> updateableParams) {
final List<Pair<String, TypeName>> result = new ArrayList<Pair<String, TypeName>>();
JQLChecker checker = JQLChecker.getInstance();
final One<Boolean> inserMode = new One<Boolean>(false);
checker.replace(method, method.jql, new JQLReplacerListenerImpl(method) {
// used in update
@Override
public String onColumnNameToUpdate(String columnName) {
String column = currentEntity.findPropertyByName(columnName).columnName;
for (Pair<String, TypeName> item : updateableParams) {
String paramNameInQuery = method.findParameterAliasByName(item.value0);
if (paramNameInQuery.equalsIgnoreCase(columnName)) {
result.add(item);
break;
}
}
return column;
}
// used in insert
@Override
public void onColumnNameSetBegin(Column_name_setContext ctx) {
inserMode.value0 = true;
}
@Override
public void onColumnNameSetEnd(Column_name_setContext ctx) {
inserMode.value0 = false;
}
@Override
public String onColumnName(String columnName) {
if (!inserMode.value0)
return columnName;
String column = currentEntity.findPropertyByName(columnName).columnName;
for (Pair<String, TypeName> item : updateableParams) {
String paramNameInQuery = method.findParameterAliasByName(item.value0);
if (paramNameInQuery.equalsIgnoreCase(columnName)) {
result.add(item);
break;
}
}
return column;
}
});
return result;
}
use of com.abubusoft.kripton.common.One 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());
}
use of com.abubusoft.kripton.common.One in project kripton by xcesco.
the class BindM2MBuilder method isMethodAlreadyDefined.
/**
* analyze DAO definition to check if method is already defined
*
* @param entity
* @param methodName
* @return
*/
private boolean isMethodAlreadyDefined(M2MEntity entity, final String methodName) {
final One<Boolean> found = new One<Boolean>(false);
SqlBuilderHelper.forEachMethods(entity.daoElement, new MethodFoundListener() {
@Override
public void onMethod(ExecutableElement executableMethod) {
if (executableMethod.getSimpleName().toString().equals(methodName)) {
found.value0 = true;
}
}
});
return found.value0;
}
use of com.abubusoft.kripton.common.One in project kripton by xcesco.
the class GenericSQLHelper method generateGenericExecSQL.
/**
* @param methodBuilder
* @param method
* @param daoDefinition
* @param schema
*/
public static void generateGenericExecSQL(MethodSpec.Builder methodBuilder, final SQLiteModelMethod method) {
final SQLiteDaoDefinition daoDefinition = method.getParent();
boolean nullable;
final List<String> paramsList = new ArrayList<String>();
final List<String> contentValueList = new ArrayList<String>();
final One<Boolean> columnsToUpdate = new One<Boolean>(true);
String sql = JQLChecker.getInstance().replace(method, method.jql, new JQLReplacerListenerImpl(method) {
@Override
public void onWhereStatementBegin(Where_stmtContext ctx) {
super.onWhereStatementBegin(ctx);
columnsToUpdate.value0 = false;
}
@Override
public void onWhereStatementEnd(Where_stmtContext ctx) {
super.onWhereStatementEnd(ctx);
columnsToUpdate.value0 = true;
}
@Override
public String onColumnName(String columnName) {
String resolvedName = currentSchema.findColumnNameByPropertyName(method, columnName);
AssertKripton.assertTrueOrUnknownPropertyInJQLException(resolvedName != null, method, columnName);
return resolvedName;
}
@Override
public String onBindParameter(String bindParameterName) {
String propertyName = method.findParameterAliasByName(bindParameterName);
if (columnsToUpdate.value0) {
contentValueList.add(propertyName);
} else {
paramsList.add(propertyName);
}
return "?";
}
});
// update/insert columns
final SQLiteEntity entity = daoDefinition.getEntity();
for (String item : contentValueList) {
// ASSERT: property is always in entity
String propertyName = method.findParameterNameByAlias(item);
TypeName paramType = method.findParameterTypeByAliasOrName(item);
SQLProperty property = entity.get(item);
if (propertyName == null)
throw (new PropertyNotFoundException(method, propertyName, paramType));
Pair<String, TypeName> methodParam = new Pair<String, TypeName>(propertyName, paramType);
// check same type
TypeUtility.checkTypeCompatibility(method, methodParam, property);
if (method.isLogEnabled()) {
methodBuilder.addCode("_contentValues.put($S, ", property.columnName);
} else {
methodBuilder.addCode("_contentValues.put(");
}
// it does not need to be converted in string
SQLTransformer.javaMethodParam2ContentValues(methodBuilder, method, methodParam.value0, methodParam.value1, property);
methodBuilder.addCode(");\n");
// if (nullable) {
// methodBuilder.nextControlFlow("else");
//
// if (method.isLogEnabled()) {
// methodBuilder.addStatement("_contentValues.putNull($S)", property.columnName);
// } else {
// methodBuilder.addStatement("_contentValues.putNull()");
// }
//
// methodBuilder.endControlFlow();
// }
}
// where condition
methodBuilder.addComment("build where condition");
{
// String separator = "";
TypeName paramType;
String realName;
for (String item : paramsList) {
methodBuilder.addCode("_contentValues.addWhereArgs(");
paramType = method.findParameterTypeByAliasOrName(item);
realName = method.findParameterNameByAlias(item);
AssertKripton.assertTrueOrUnknownPropertyInJQLException(paramType != null, method, item);
// code for query arguments
nullable = TypeUtility.isNullable(paramType);
if (nullable) {
methodBuilder.addCode("($L==null?\"\":", realName);
}
// check for string conversion
TypeUtility.beginStringConversion(methodBuilder, paramType);
SQLTransformer.javaMethodParam2ContentValues(methodBuilder, method, realName, paramType, null);
// check for string conversion
TypeUtility.endStringConversion(methodBuilder, paramType);
if (nullable) {
methodBuilder.addCode(")");
}
methodBuilder.addCode(");\n");
}
}
// log for where parames
SqlBuilderHelper.generateLog(method, methodBuilder);
// log
methodBuilder.addCode("\n");
methodBuilder.addStatement("database().execSQL($S, _contentValues.whereArgsAsArray())", sql);
}
use of com.abubusoft.kripton.common.One in project kripton by xcesco.
the class InsertRawHelper method generateJavaDoc.
/**
* @param methodBuilder
* @param method
* @param returnType
* @return string sql
*/
public String generateJavaDoc(MethodSpec.Builder methodBuilder, final SQLiteModelMethod method, TypeName returnType) {
final SQLiteDaoDefinition daoDefinition = method.getParent();
final SQLiteEntity entity = daoDefinition.getEntity();
final One<Boolean> inColumnValues = new One<Boolean>(false);
final List<Pair<String, TypeName>> methodParamsUsedAsColumnValue = new ArrayList<>();
final List<Pair<String, TypeName>> methodParamsUsedAsParameter = new ArrayList<>();
// transform JQL to SQL
String sqlInsert = JQLChecker.getInstance().replace(method, method.jql, new JQLReplacerListenerImpl(method) {
@Override
public void onColumnValueSetBegin(Column_value_setContext ctx) {
inColumnValues.value0 = true;
}
@Override
public void onColumnValueSetEnd(Column_value_setContext ctx) {
inColumnValues.value0 = false;
}
@Override
public String onColumnName(String columnName) {
Set<SQLProperty> property = currentSchema.getPropertyBySimpleName(columnName);
AssertKripton.assertTrueOrUnknownPropertyInJQLException(property != null, method, columnName);
SQLProperty tempProperty = property.iterator().next();
AssertKripton.assertTrueOrUnknownPropertyInJQLException(tempProperty != null, method, columnName);
return tempProperty.columnName;
}
@Override
public String onBindParameter(String bindParameterName) {
String resolvedParamName = method.findParameterNameByAlias(bindParameterName);
if (inColumnValues.value0) {
methodParamsUsedAsColumnValue.add(new Pair<>(resolvedParamName, method.findParameterType(resolvedParamName)));
} else {
methodParamsUsedAsParameter.add(new Pair<>(resolvedParamName, method.findParameterType(resolvedParamName)));
}
return "${" + resolvedParamName + "}";
}
});
methodBuilder.addJavadoc("<h2>SQL insert</h2>\n");
methodBuilder.addJavadoc("<pre>$L</pre>\n", sqlInsert);
methodBuilder.addJavadoc("\n");
if (methodParamsUsedAsColumnValue.size() > 0) {
// list of inserted fields
methodBuilder.addJavadoc("<h2>Inserted columns:</strong></h2>\n");
methodBuilder.addJavadoc("<dl>\n");
for (Pair<String, TypeName> property : methodParamsUsedAsColumnValue) {
// String resolvedName = method.findParameterAliasByName(property.value0);
String resolvedName = method.findParameterNameByAlias(property.value0);
/*SQLProperty prop = entity.get(resolvedName);
if (prop == null)
throw (new PropertyNotFoundException(method, property.value0, property.value1));*/
methodBuilder.addJavadoc("\t<dt>$L</dt>", property.value0);
methodBuilder.addJavadoc("<dd>is binded to query's parameter <strong>$L</strong> and method's parameter <strong>$L</strong></dd>\n", "${" + property.value0 + "}", resolvedName);
}
methodBuilder.addJavadoc("</dl>\n\n");
}
// list of parameters
if (methodParamsUsedAsParameter.size() > 0) {
methodBuilder.addJavadoc("<h2>Method parameters used as sql parameters</h2>\n");
methodBuilder.addJavadoc("<dl>\n");
for (Pair<String, TypeName> property : methodParamsUsedAsParameter) {
String resolvedName = method.findParameterNameByAlias(property.value0);
methodBuilder.addJavadoc("\t<dt>$L</dt>", resolvedName);
methodBuilder.addJavadoc("<dd>is binded to query's parameter <strong>$${$L}</strong></dd>\n", property.value0);
}
methodBuilder.addJavadoc("</dl>\n\n");
}
for (Pair<String, TypeName> param : method.getParameters()) {
if (methodParamsUsedAsColumnValue.contains(param)) {
methodBuilder.addJavadoc("@param $L\n", param.value0);
if (entity.get(method.findParameterAliasByName(param.value0)) != null) {
methodBuilder.addJavadoc("\tis binded to column value <strong>$L</strong>\n", entity.get(method.findParameterAliasByName(param.value0)).columnName);
} else {
// in case of JQL explicit, you can declare name of parameter
methodBuilder.addJavadoc("\tis binded to query parameter <strong>$L</strong>\n", param.value0);
}
}
if (methodParamsUsedAsParameter.contains(param)) {
methodBuilder.addJavadoc("@param $L\n", param.value0);
methodBuilder.addJavadoc("\tis used as parameter\n");
}
}
generateJavaDocReturnType(methodBuilder, returnType);
return sqlInsert;
}
Aggregations