@Override public <V extends BValue> V getEmptyValue() { return (V) new BTable(); }
public void addData(BMap<String, BValue> data) { addData(data, null); }
@Override public String stringValue() { String constraint = constraintType != null ? "<" + constraintType.toString() + ">" : ""; StringBuilder tableWrapper = new StringBuilder("table" + constraint + " "); StringJoiner tableContent = new StringJoiner(", ", "{", "}"); tableContent.add(createStringValueEntry("index", indices)); tableContent.add(createStringValueEntry("primaryKey", primaryKeys)); tableContent.add(createStringValueDataEntry()); tableWrapper.append(tableContent.toString()); return tableWrapper.toString(); }
public boolean hasNext() { if (tableClosed) { throw new BallerinaException("Trying to perform hasNext operation over a closed table"); } if (isIteratorGenerationConditionMet()) { generateIterator(); } if (!nextPrefetched) { hasNextVal = iterator.next(); nextPrefetched = true; } if (!hasNextVal) { reset(); } return hasNextVal; }
switch (type) { case BOOLEAN: value = String.valueOf(table.getBoolean(index)); break; case STRING: value = table.getString(index); break; case INT: value = String.valueOf(table.getInt(index)); break; case FLOAT: value = String.valueOf(table.getFloat(index)); break; case BLOB: value = table.getBlob(index); break; case ARRAY: isArray = true; Object[] array = table.getArray(index); processArray(xmlStreamWriter, array); break; case RECORD: isArray = true; Object[] structData = table.getStruct(index); if (structFields == null) { processArray(xmlStreamWriter, structData); value = table.getString(index);
@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(); }
@Override public boolean hasNext() { return this.df.hasNext(); }
@Override public BValue copy(Map<BValue, BValue> refs) { if (tableClosed) { throw new BallerinaException("Trying to invoke clone built-in method over a closed table"); } if (isFrozen()) { return this; } if (refs.containsKey(this)) { return refs.get(this); } TableIterator cloneIterator = tableProvider.createIterator(this.tableName, this.constraintType); BValueArray data = new BValueArray(); int cursor = 0; try { while (cloneIterator.next()) { data.add(cursor++, cloneIterator.generateNext()); } BTable table = new BTable(new BTableType(constraintType), this.indices, this.primaryKeys, data); refs.put(this, table); return table; } finally { cloneIterator.close(); } }
@Override public BValue getNext() { if (hasNext()) { return table.getNext(); } return null; }
public void moveToNext() { if (tableClosed) { throw new BallerinaException(BallerinaErrorReasons.TABLE_CLOSED_ERROR, "Trying to perform an operation over a closed table"); } if (isIteratorGenerationConditionMet()) { generateIterator(); } if (!nextPrefetched) { iterator.next(); } else { nextPrefetched = false; } }
public void execute(Context ctx) { BTable table = (BTable) ctx.getRefArgument(0); table.close(); ctx.setReturnValues(); } }
private static BRefType<?> getDataArray(BTable df, int columnIndex) { Object[] dataArray = df.getArray(columnIndex); int length = dataArray.length; BValueArray jsonArray = new BValueArray(new BArrayType(BTypes.typeJSON));
switch (type) { case STRING: jsonObject.put(name, getBString(df.getString(index))); break; case INT: Long intVal = df.getInt(index); jsonObject.put(name, intVal == null ? null : new BInteger(intVal)); break; case FLOAT: Double floatVal = df.getFloat(index); jsonObject.put(name, floatVal == null ? null : new BFloat(floatVal)); break; case BOOLEAN: Boolean boolVal = df.getBoolean(index); jsonObject.put(name, boolVal == null ? null : new BBoolean(boolVal)); break; case BLOB: jsonObject.put(name, getBString(df.getBlob(index))); break; case ARRAY: break; case JSON: jsonObject.put(name, df.getString(index) == null ? null : JsonParser.parse(df.getString(index))); break; case OBJECT: case RECORD: jsonObject.put(name, getStructData(df.getStruct(index), structFields, index)); break;
@Override public boolean hasNext() { return table.hasNext(); }
public void execute(Context context) { BTable table = (BTable) context.getRefArgument(0); context.setReturnValues(table.getNext()); } }
/** * Where extern function logic is implemented. * * @param context Current Context instance */ @Override public void execute(Context context) { String query = context.getStringArgument(0); BTable fromTable = (BTable) context.getRefArgument(0); BValueArray array = (BValueArray) context.getRefArgument(1); BMap<String, BValue> tableTypeStruct = (BMap<String, BValue>) context.getRefArgument(2); context.setReturnValues(new BTable(query, fromTable, null, (BStructureType) tableTypeStruct.getType(), array)); } }
public void execute(Context context) { BTable table = (BTable) context.getRefArgument(0); context.setReturnValues(new BBoolean(table.hasNext())); } }
private void insertInitialData(BValueArray data) { int count = (int) data.size(); for (int i = 0; i < count; i++) { addData((BMap<String, BValue>) data.getRefValue(i)); } }