/** * @return the default value given by any existing {@link ColumnSpec} definition, or {@link ColumnSpec#DEFAULT_NONE} * if none is set */ protected String getColumnDefault() { return extras != null ? extras.defaultValue() : ColumnSpec.DEFAULT_NONE; }
@Override protected String getGeneratedClassNameString() { return modelSpecAnnotation.className(); }
@Override protected String getGeneratedClassNameString() { return modelSpecAnnotation.className(); }
private void emitTableDeclaration() throws IOException { writer.writeComment("--- table declaration"); List<Object> arguments = new ArrayList<>(); arguments.add(Expressions.classObject(modelSpec.getGeneratedClassName())); // modelClass arguments.add(PROPERTIES_ARRAY_NAME); // properties arguments.add("\"" + modelSpec.getSpecAnnotation().tableName().trim() + "\""); // name arguments.add(null); // database name, null by default if (modelSpec.isVirtualTable()) { if (AptUtils.isEmpty(modelSpec.getSpecAnnotation().virtualModule())) { modelSpec.logError("virtualModule should be non-empty for virtual table models", modelSpec.getModelSpecElement()); } arguments.add("\"" + modelSpec.getSpecAnnotation().virtualModule() + "\""); } else if (!AptUtils.isEmpty(modelSpec.getSpecAnnotation().tableConstraint())) { arguments.add("\"" + modelSpec.getSpecAnnotation().tableConstraint() + "\""); } writer.writeFieldDeclaration(modelSpec.getTableType(), TABLE_NAME, Expressions.callConstructor(modelSpec.getTableType(), arguments), TypeConstants.PUBLIC_STATIC_FINAL); writer.writeFieldDeclaration(TypeConstants.TABLE_MODEL_NAME, TABLE_MODEL_NAME, Expressions.callConstructor(TypeConstants.TABLE_MODEL_NAME, Expressions.classObject(modelSpec.getGeneratedClassName()), Expressions.callMethodOn(TableModelFileWriter.TABLE_NAME, "getName")), TypeConstants.PUBLIC_STATIC_FINAL); writer.writeNewline(); }
String constraints = extras != null ? extras.constraints() : ColumnSpec.DEFAULT_NONE; if (!ColumnSpec.DEFAULT_NONE.equals(constraints)) { toReturn.append(constraints); if (!toReturn.toString().toUpperCase().contains("PRIMARY KEY")) { toReturn.append(" PRIMARY KEY "); if (TypeConstants.isIntegerType(getTypeForAccessors()) && primaryKeyAnnotation.autoincrement()) { toReturn.append("AUTOINCREMENT");
private void emitSqlTableDeclaration(boolean view) throws IOException { writer.writeComment("--- " + (view ? "view" : "subquery") + " declaration"); String name = "\"" + modelSpec.getSpecAnnotation().viewName().trim() + "\""; if (modelSpec.getQueryElement() != null) { Expression queryReference = Expressions.staticReference(modelSpec.getModelSpecName(), modelSpec.getQueryElement().getSimpleName().toString()) .callMethod("selectMore", ALIASED_PROPERTY_ARRAY_NAME); if (modelSpec.getViewQueryAnnotation().freeze()) { queryReference = queryReference.callMethod("freeze"); } writer.writeFieldDeclaration(TypeConstants.QUERY, QUERY_NAME, queryReference, TypeConstants.PUBLIC_STATIC_FINAL); Expression initializer = constructInitializer(name, view); writer.writeFieldDeclaration(view ? TypeConstants.VIEW : TypeConstants.SUBQUERY_TABLE, view ? VIEW_NAME : SUBQUERY_NAME, initializer, TypeConstants.PUBLIC_STATIC_FINAL); } else { writer.writeFieldDeclaration(CoreTypes.JAVA_STRING, view ? "VIEW_NAME" : "SUBQUERY_NAME", Expressions.fromString(name), TypeConstants.PUBLIC_STATIC_FINAL); } writer.writeNewline(); }
@Override protected void addModelSpecificImports(Set<DeclaredTypeName> imports) { if (hasMetadata(METADATA_KEY_QUERY_ELEMENT)) { if (modelSpecAnnotation.isSubquery()) { imports.add(TypeConstants.SUBQUERY_TABLE); } else { imports.add(TypeConstants.VIEW); } imports.add(TypeConstants.QUERY); } } }
@Override protected DeclaredTypeName getDefaultModelSuperclass() { if (superclass == null) { return new DeclaredTypeName(getSpecAnnotation().inheritsFrom()); } return superclass; }
@Override protected PropertyGenerator getPropertyGenerator(VariableElement field, DeclaredTypeName fieldType) { Alias alias = field.getAnnotation(Alias.class); if (alias != null) { SqlUtils.checkIdentifier(alias.value().trim(), "view column name", modelSpec, field, utils); } return super.getPropertyGenerator(field, fieldType); } }
@Override protected String getGeneratedClassNameString() { return modelSpecAnnotation.className(); }
/** * @return true if the table model is for a virtual table, false otherwise */ public boolean isVirtualTable() { return !AptUtils.isEmpty(modelSpecAnnotation.virtualModule()); }
private boolean shouldGenerateROWIDProperty() { TableModelSpecWrapper tableModelSpec = (TableModelSpecWrapper) modelSpec; return tableModelSpec.isVirtualTable() || tableModelSpec.hasMetadata(METADATA_KEY_HAS_PRIMARY_KEY) || tableModelSpec.getSpecAnnotation().noRowIdAlias(); }
private void checkTableName() { String tableName = getSpecAnnotation().tableName().trim(); if (tableName.toLowerCase().startsWith("sqlite_")) { logError("Table names cannot start with 'sqlite_'; such names are reserved for internal use", getModelSpecElement()); } else { SqlUtils.checkIdentifier(tableName, "table", this, getModelSpecElement(), utils); } }
private void checkViewName() { String viewName = getSpecAnnotation().viewName().trim(); if (viewName.toLowerCase().startsWith("sqlite_")) { logError("View names cannot start with 'sqlite_'; such names are reserved for internal use", getModelSpecElement()); } else { SqlUtils.checkIdentifier(viewName, "view", this, getModelSpecElement(), utils); } }
private void emitModelMethod(JavaFileWriter writer, ExecutableElement e, Modifier... modifiers) throws IOException { MethodDeclarationParameters params = utils.methodDeclarationParamsFromExecutableElement(e, modifiers); ModelMethod methodAnnotation = e.getAnnotation(ModelMethod.class); List<Object> arguments = new ArrayList<>(); if (methodAnnotation != null) { String name = methodAnnotation.name(); if (!AptUtils.isEmpty(name)) { params.setMethodName(name); } params.getArgumentTypes().remove(0); params.getArgumentNames().remove(0); arguments.add(0, "this"); } arguments.addAll(params.getArgumentNames()); Expression methodCall = Expressions.staticMethod(modelSpec.getModelSpecName(), e.getSimpleName().toString(), arguments); if (!CoreTypes.VOID.equals(params.getReturnType())) { methodCall = methodCall.returnExpr(); } JavadocPlugin.writeJavadocFromElement(pluginEnv, writer, e); writer.beginMethodDefinition(params) .writeStatement(methodCall) .finishMethodDefinition(); }
private void emitQueryAndTableDeclaration() throws IOException { emitSqlTableDeclaration(!modelSpec.getSpecAnnotation().isSubquery()); }
public InheritedModelSpecWrapper(TypeElement modelSpecElement, PluginEnvironment pluginEnv, AptUtils utils) { super(modelSpecElement, InheritedModelSpec.class, pluginEnv, utils); this.superclass = new DeclaredTypeName(getSpecAnnotation().inheritsFrom()); }
private boolean emitPropertyReferenceArrayBody(boolean alias) throws IOException { for (PropertyGenerator propertyGenerator : modelSpec.getPropertyGenerators()) { Expression reference = Expressions.staticReference(modelSpec.getModelSpecName(), propertyGenerator.getPropertyName()); if (alias) { VariableElement field = propertyGenerator.getField(); if (field != null) { Alias aliasAnnotation = field.getAnnotation(Alias.class); if (aliasAnnotation != null && !AptUtils.isEmpty(aliasAnnotation.value().trim())) { reference = reference.callMethod("as", "\"" + aliasAnnotation.value().trim() + "\""); } } } writer.writeExpression(reference); writer.appendString(",\n"); } return !AptUtils.isEmpty(modelSpec.getPropertyGenerators()); }
private void emitSinglePropertyDeclaration(PropertyGenerator generator, int index) throws IOException { modelSpec.getPluginBundle().beforeEmitPropertyDeclaration(writer, generator); DeclaredTypeName type = generator.getPropertyType(); String fieldToQualify = ALIASED_PROPERTY_ARRAY_NAME + "[" + index + "]"; Expression expressionToCast; if (modelSpec.getQueryElement() != null) { String callOn = modelSpec.getSpecAnnotation().isSubquery() ? SUBQUERY_NAME : VIEW_NAME; expressionToCast = Expressions.callMethodOn(callOn, "qualifyField", fieldToQualify); } else { expressionToCast = Expressions.reference(fieldToQualify); } writer.writeFieldDeclaration(type, generator.getPropertyName(), expressionToCast.cast(type), TypeConstants.PUBLIC_STATIC_FINAL) .writeNewline(); modelSpec.getPluginBundle().afterEmitPropertyDeclaration(writer, generator); }