public static String generateDeleteDataStatment(String tableName, BMap<?, ?> constrainedType) { StringBuilder sbSql = new StringBuilder(); sbSql.append(TableConstants.SQL_DELETE_FROM).append(tableName).append(TableConstants.SQL_WHERE); Collection<BField> structFields = ((BStructureType) constrainedType.getType()).getFields().values(); String sep = ""; for (BField sf : structFields) { String name = sf.getFieldName(); sbSql.append(sep).append(name).append(" = ? "); sep = TableConstants.SQL_AND; } return sbSql.toString(); }
public static String generateInsertDataStatment(String tableName, BMap<?, ?> constrainedType) { StringBuilder sbSql = new StringBuilder(); StringBuilder sbValues = new StringBuilder(); sbSql.append(TableConstants.SQL_INSERT_INTO).append(tableName).append(" ("); Collection<BField> structFields = ((BStructureType) constrainedType.getType()).getFields().values(); String sep = ""; for (BField sf : structFields) { String name = sf.getFieldName(); sbSql.append(sep).append(name).append(" "); sbValues.append(sep).append("?"); sep = ","; } sbSql.append(") values (").append(sbValues).append(")"); return sbSql.toString(); }
private static boolean checkPrivateObjectsEquivalency(BStructureType lhsType, BStructureType rhsType, List<TypePair> unresolvedTypes) { Map<String, BField> rhsFields = rhsType.getFields(); for (Map.Entry<String, BField> lhsFieldEntry : lhsType.getFields().entrySet()) { BField rhsField = rhsFields.get(lhsFieldEntry.getKey()); if (rhsField == null || !isSameType(rhsField.fieldType, lhsFieldEntry.getValue().fieldType)) { return false; } } BAttachedFunction[] lhsFuncs = lhsType.getAttachedFunctions(); BAttachedFunction[] rhsFuncs = rhsType.getAttachedFunctions(); for (BAttachedFunction lhsFunc : lhsFuncs) { if (lhsFunc == lhsType.initializer || lhsFunc == lhsType.defaultsValuesInitFunc) { continue; } BAttachedFunction rhsFunc = getMatchingInvokableType(rhsFuncs, lhsFunc, unresolvedTypes); if (rhsFunc == null) { return false; } } return true; }
StructImpl(BMap<String, BValue> value) { this.value = value; type = (BStructureType) value.getType(); type.getFields().values().forEach(sf -> { final StructFieldImpl structField = new StructFieldImpl(sf.fieldName, sf.fieldType.getTag()); setIndex(structField, indexes); structFields.put(sf.fieldName, structField); }); }
switch (type.getTag()) { case TypeTags.OBJECT_TYPE_TAG: for (Map.Entry<String, BField> field : ((BStructureType) this.type).getFields().entrySet()) { if (!Flags.isFlagOn(field.getValue().flags, Flags.PUBLIC)) { continue;
private static boolean checkPublicObjectsEquivalency(BStructureType lhsType, BStructureType rhsType, List<TypePair> unresolvedTypes) { if (rhsType.getFields().values().stream().anyMatch(field -> !Flags.isFlagOn(field.flags, Flags.PUBLIC))) { return false; Map<String, BField> rhsFields = rhsType.getFields(); for (Map.Entry<String, BField> lhsFieldEntry : lhsType.getFields().entrySet()) { BField rhsField = rhsFields.get(lhsFieldEntry.getKey()); if (rhsField == null || !Flags.isFlagOn(lhsFieldEntry.getValue().flags, Flags.PUBLIC) ||
if (internaltType.getTag() == TypeTags.OBJECT_TYPE_TAG || internaltType.getTag() == TypeTags.RECORD_TYPE_TAG) { BField[] internalStructFields = ((BStructureType) internaltType).getFields() .values().toArray(new BField[0]); if (internalStructFields != null) {
switch (type.getTag()) { case TypeTags.OBJECT_TYPE_TAG: ((BStructureType) this.type).getFields().forEach((fieldName, field) -> { V fieldVal = get((K) fieldName); sj.add((fieldName + ":" + getStringValue(fieldVal)));
@Override public void serialize(XMLStreamWriter xmlStreamWriter) throws XMLStreamException { xmlStreamWriter.writeStartElement("", this.rootWrapper, ""); while (table.hasNext()) { table.moveToNext(); xmlStreamWriter.writeStartElement("", this.rowWrapper, ""); BStructureType structType = table.getStructType(); BField[] structFields = null; if (structType != null) { structFields = structType.getFields().values().toArray(new BField[0]); } int index = 1; for (ColumnDefinition col : table.getColumnDefs()) { String name; if (structFields != null) { name = structFields[index - 1].getFieldName(); } else { name = col.getName(); } writeElement(xmlStreamWriter, name, col.getType(), index, structFields); ++index; } xmlStreamWriter.writeEndElement(); } xmlStreamWriter.writeEndElement(); xmlStreamWriter.flush(); }
private void generateColumnDefinitions() { Collection<BField> structFields = this.type.getFields().values(); columnDefs = new ArrayList<>(structFields.size()); for (BField sf : structFields) {
@Override public BRefType<?> transform(BTable df) throws IOException { BMap<String, BRefType<?>> objNode = new BMap<>(BTypes.typeJSON); BStructureType structType = df.getStructType(); BField[] structFields = null; if (structType != null) { structFields = structType.getFields().values().toArray(new BField[0]); } int index = 0; for (ColumnDefinition col : df.getColumnDefs()) { String name; if (structFields != null) { name = structFields[index].getFieldName(); } else { name = col.getName(); } constructJsonData(df, objNode, name, col.getType(), index + 1, structFields); ++index; } return objNode; }
/** * Create BStruct for given StructInfo and BValues. * * @param structInfo {@link StructureTypeInfo} of the BStruct * @param values field values of the BStruct. * @return Struct value. */ public static BMap<String, BValue> createBStruct(StructureTypeInfo structInfo, Object... values) { BStructureType structType = structInfo.getType(); BMap<String, BValue> bStruct = new BMap<>(structType); Map<String, BField> structFields = structType.getFields(); int valCount = 0; for (BField field : structFields.values()) { BValue value; if (values.length >= valCount + 1) { value = getBValue(field.fieldType, values[valCount]); } else { value = field.fieldType.getEmptyValue(); } bStruct.put(field.fieldName, value); valCount++; } return bStruct; }
@Override public void receive(Event[] events) { BValueArray outputArray = new BValueArray(new BMapType(structType)); int j = 0; for (Event event : events) { // Here it is assumed that an event data will contain all the fields // of the record. Otherwise, some fields will be missing from the record value. BMap<String, BValue> output = new BMap<String, BValue>(structType); Iterator<String> fieldNamesIterator = structType.getFields().keySet().iterator(); for (Object field : event.getData()) { if (field instanceof Long || field instanceof Integer) { output.put(fieldNamesIterator.next(), new BInteger(((Number) field).longValue())); } else if (field instanceof Double || field instanceof Float) { output.put(fieldNamesIterator.next(), new BFloat(((Number) field).doubleValue())); } else if (field instanceof Boolean) { output.put(fieldNamesIterator.next(), new BBoolean(((Boolean) field))); } else if (field instanceof String) { output.put(fieldNamesIterator.next(), new BString((String) field)); } } outputArray.add(j, output); j++; } List<BValue> argsList = new ArrayList<>(); argsList.addAll(closureArgs); argsList.add(outputArray); BVMExecutor.executeFunction(functionPointer.value().getPackageInfo().getProgramFile(), functionPointer.value(), argsList.toArray(new BValue[0])); } });
((BStructureType) targetType.getConstrainedType()).getFields().entrySet()) { String key = fieldEntry.getKey(); BValue value = map.get(key);
int index = 0; try { Collection<BField> structFields = type.getFields().values(); for (BField sf : structFields) { BType type = sf.getFieldType();
private Object[] createEvent(BMap<String, BValue> data) { BStructureType streamType = (BStructureType) data.getType(); Object[] event = new Object[streamType.getFields().size()]; int index = 0; for (Map.Entry<String, BField> fieldEntry : streamType.getFields().entrySet()) { BField field = fieldEntry.getValue(); switch (field.getFieldType().getTag()) { case TypeTags.INT_TAG: event[index++] = ((BInteger) data.get(field.fieldName)).intValue(); break; case TypeTags.FLOAT_TAG: event[index++] = ((BFloat) data.get(field.fieldName)).floatValue(); break; case TypeTags.BOOLEAN_TAG: event[index++] = ((BBoolean) data.get(field.fieldName)).booleanValue(); break; case TypeTags.STRING_TAG: event[index++] = data.get(field.fieldName).stringValue(); break; default: throw new BallerinaException("Fields in streams do not support data types other than int, " + "float, boolean and string"); } } return event; }
siddhiQuery = siddhiQuery.replaceFirst("\\[\\[streamName\\]\\]", stream.getStreamId()); Map<String, BField> structFields = ((BStructureType) stream.getConstraintType()).getFields(); StringBuilder streamDefinition = new StringBuilder("define stream "); streamDefinition.append(stream.getStreamId()).append("( ");
public static void prepareAndExecuteStatement(PreparedStatement stmt, BMap<String, BValue> constrainedType) { try { Collection<BField> structFields = ((BStructureType) constrainedType.getType()).getFields().values(); int index = 1; for (BField sf : structFields) {
BType restFieldType = ((BRecordType) type).restFieldType; for (BField field : ((BStructureType) type).getFields().values()) { targetTypeField.put(field.getFieldName(), field.fieldType);