for (RecordDataSchema.Field field : recordDataSchema.getFields())
/** * Build the schema of a {@link DynamicRecordTemplate}. * * @param name the name of the record. * @param fieldDefs the fields of the record. * @throws IllegalArgumentException if the {@link com.linkedin.data.schema.RecordDataSchema.Field} of the fieldDefs * are already set. */ public static RecordDataSchema buildSchema(String name, Collection<? extends FieldDef<?>> fieldDefs) { StringBuilder errorMessageBuilder = new StringBuilder(); RecordDataSchema schema = new RecordDataSchema(new Name(name, errorMessageBuilder), RecordDataSchema.RecordType.RECORD); List<RecordDataSchema.Field> fields = new ArrayList<RecordDataSchema.Field>(fieldDefs.size()); for (FieldDef<?> fieldDef: fieldDefs) { RecordDataSchema.Field paramField = fieldDef.getField(); if (paramField.getRecord() != null) { throw new IllegalArgumentException("Attempt to assign field "+ fieldDef.getName() + " to record " + schema.getName() + "failed: " + "Record of field is already set to " + paramField.getRecord().getName() ); } paramField.setRecord(schema); fields.add(paramField); } schema.setFields(fields, errorMessageBuilder); return schema; }
private void checkAlternativeKeySchema(AlternativeKeySchema prevRec, AlternativeKeySchema currRec) { checkEqualSingleValue(prevRec.schema().getField("name"), prevRec.getName(GetMode.DEFAULT), currRec.getName(GetMode.DEFAULT)); checkDoc(prevRec.schema().getField("doc"), prevRec.getDoc(GetMode.DEFAULT), currRec.getDoc(GetMode.DEFAULT)); checkEqualSingleValue(prevRec.schema().getField("type"), prevRec.getType(GetMode.DEFAULT), currRec.getType(GetMode.DEFAULT)); checkEqualSingleValue(prevRec.schema().getField("keyCoercer"), prevRec.getKeyCoercer(GetMode.DEFAULT), currRec.getKeyCoercer(GetMode.DEFAULT)); }
private static String toRecordLiteral(StringBuilder sb, DataMap dataMap, RecordDataSchema recordSchema) { Iterator<RecordDataSchema.Field> iter = recordSchema.getFields().iterator(); sb.append(escapeKeyword(recordSchema.getName())); sb.append("("); while (iter.hasNext()) { RecordDataSchema.Field field = iter.next(); sb.append(escapeKeyword(field.getName())); sb.append(": "); sb.append(toLiteral(field.getType(), dataMap.get(field.getName()))); if (iter.hasNext()) { sb.append(", "); } } sb.append(")"); return sb.toString(); }
private RecordDataSchema parseRecord( NamedTypeDeclarationContext context, RecordDeclarationContext record) throws ParseException { Name name = toName(record.name); RecordDataSchema schema = new RecordDataSchema(name, RecordDataSchema.RecordType.RECORD); bindNameToSchema(name, schema); FieldsAndIncludes fieldsAndIncludes = parseFields(schema, record.recordDecl); schema.setFields(fieldsAndIncludes.fields, errorMessageBuilder()); validateDefaults(schema); schema.setInclude(fieldsAndIncludes.includes); setProperties(context, schema); return schema; }
private RecordDataSchema parseRecord( NamedTypeDeclarationContext context, RecordDeclarationContext record) throws ParseException { Name name = toName(record.name); RecordDataSchema schema = new RecordDataSchema(name, RecordDataSchema.RecordType.RECORD); bindNameToSchema(name, schema); FieldsAndIncludes fieldsAndIncludes = parseIncludes(record.beforeIncludes); boolean hasBeforeIncludes = fieldsAndIncludes.includes.size() > 0; fieldsAndIncludes.fields.addAll(parseFields(schema, record.recordDecl)); FieldsAndIncludes afterIncludes = parseIncludes(record.afterIncludes); boolean hasAfterIncludes = afterIncludes.includes.size() > 0; if (hasBeforeIncludes && hasAfterIncludes) { startErrorMessage(record) .append("Record may have includes before or after fields, but not both: ") .append(record).append(NEWLINE); } fieldsAndIncludes.addAll(afterIncludes); schema.setFields(fieldsAndIncludes.fields, errorMessageBuilder()); schema.setInclude(fieldsAndIncludes.includes); schema.setIncludesDeclaredInline(fieldsAndIncludes.includesDeclaredInline); schema.setFieldsBeforeIncludes(hasAfterIncludes); validateDefaults(schema); setProperties(context, schema); return schema; }
private RecordTemplateSpec generateRecord(RecordDataSchema schema) recordClass.setNamespace(schema.getNamespace()); recordClass.setClassName(schema.getName()); recordClass.setModifiers(ModifierSpec.PUBLIC); registerClassTemplateSpec(schema, recordClass); final List<NamedDataSchema> includes = schema.getInclude(); for (NamedDataSchema includedSchema : includes) final Map<CustomInfoSpec, Object> customInfoMap = new IdentityHashMap<CustomInfoSpec, Object>(schema.getFields().size() * 2); for (RecordDataSchema.Field field : schema.getFields())
private void writeRecord(RecordDataSchema schema) throws IOException boolean hasDoc = writeDoc(schema.getDoc()); boolean hasProperties = writeProperties(schema.getProperties()); if (hasDoc || hasProperties) { indent(); List<NamedDataSchema> includes = schema.getInclude(); if (includes.size() > 0 && !schema.isFieldsBeforeIncludes()) for (RecordDataSchema.Field field : schema.getFields()) if (field.getRecord().equals(schema)) write("}"); if (includes.size() > 0 && schema.isFieldsBeforeIncludes())
for (NamedDataSchema includedSchema : recordDataSchema.getInclude()) for(RecordDataSchema.Field field : recordDataSchema.getFields())
append("\"").append(recordSchema.getFullName()).append("\" cannot include "). append(includedSchema).append(" because it is not a record.\n"); include.add(includedNamed); RecordDataSchema includedRecord = (RecordDataSchema) includedSchema.getDereferencedDataSchema(); fields.addAll(includedRecord.getFields()); recordSchema.setInclude(include);
@Override public RecordDataSchema schema() { synchronized (this) { // Don't use double-checked locking because _schema isn't volatile if (_schema == null) { final StringBuilder errorMessageBuilder = new StringBuilder(10); final Name elementSchemaName = new Name(_valueClass.getSimpleName(), errorMessageBuilder); final MapDataSchema resultsSchema = new MapDataSchema(new RecordDataSchema(elementSchemaName, RecordDataSchema.RecordType.RECORD)); final RecordDataSchema.Field resultsField = new RecordDataSchema.Field(resultsSchema); resultsField.setName(RESULTS, errorMessageBuilder); final MapDataSchema errorsSchema = new MapDataSchema(DataTemplateUtil.getSchema(ErrorResponse.class)); final RecordDataSchema.Field errorsField = new RecordDataSchema.Field(errorsSchema); errorsField.setName(ERRORS, errorMessageBuilder); final Name name = new Name(BATCH_KV_RESPONSE_CLASSNAME, errorMessageBuilder); _schema = new RecordDataSchema(name, RecordDataSchema.RecordType.RECORD); _schema.setFields(Arrays.asList(resultsField, errorsField), errorMessageBuilder); } } return _schema; }
public String typeName() { return escapeKeyword(_schema.getName(), EscapeStrategy.MANGLE); }
List<RecordDataSchema.Field> commonFields = new ArrayList<RecordDataSchema.Field>(newer.getFields().size()); List<String> newerRequiredAdded = new CheckerArrayList<String>(); List<String> newerRequiredWithDefaultAdded = new CheckerArrayList<>(); List<String> requiredToRequiredWithDefault = new CheckerArrayList<String>(); for (RecordDataSchema.Field newerField : newer.getFields()) RecordDataSchema.Field olderField = older.getField(fieldName); for (RecordDataSchema.Field olderField : older.getFields()) RecordDataSchema.Field newerField = newer.getField(fieldName); if (newerField == null) RecordDataSchema.Field olderField = older.getField(fieldName); assert(olderField != null); check(olderField.getType(), newerField.getType());
String typeUpper = ((String) map.get(TYPE_KEY)).toUpperCase(); RecordDataSchema.RecordType recordType = RecordDataSchema.RecordType.valueOf(typeUpper); RecordDataSchema recordSchema = new RecordDataSchema(name, recordType); schema = namedSchema = recordSchema; bindNameToSchema(name, aliasNames, recordSchema); recordSchema.setFieldsBeforeIncludes(true); recordSchema.setFields(fields, startCalleeMessageBuilder()); appendCalleeMessage(fieldsList);
for (RecordDataSchema.Field field : recordSchema.getFields()) append("Default value ").append(value). append(" of field \"").append(field.getName()). append("\" declared in record \"").append(recordSchema.getFullName()). append("\" failed validation.\n"); MessageUtil.appendMessages(errorMessageBuilder(), result.getMessages());
case RECORD: RecordDataSchema recordDataSchema = (RecordDataSchema) schema; boolean hasIncludes = isEncodeInclude() && !recordDataSchema.getInclude().isEmpty(); boolean fieldsBeforeIncludes = recordDataSchema.isFieldsBeforeIncludes(); if (hasIncludes && !fieldsBeforeIncludes)
if (emitSource) errorMessageBuilder.append(" defined in \"").append(oldField.getRecord().getFullName()).append("\""); errorMessageBuilder.append(" defined in \"").append(field.getRecord().getFullName()).append("\""); if (ok == false) setHasError();
private void writeIncludes(RecordDataSchema recordDataSchema) throws IOException { _builder.writeFieldName(INCLUDE_KEY); _builder.writeStartArray(); for (NamedDataSchema includedSchema : recordDataSchema.getInclude()) { encode(includedSchema); } _builder.writeEndArray(); }
throw new IllegalArgumentException("Cannot remove mandatory field " + field.getName() + " of " + _schema.getFullName()); throw new NullPointerException("Cannot set field " + field.getName() + " of " + _schema.getFullName() + " to null"); default: throw new IllegalStateException("Unknown mode " + mode);