@Override public void write(final Map<String, Object> row) throws IOException { final byte[] bytes; if (shouldWriteHeader) { // Write the header once (mapper.writer will clone the writer). Add a small marker in front of the header // to easily split it write(String.format("-- %s ", currentTableName).getBytes()); bytes = mapper.writer(currentCSVSchema.withHeader()).writeValueAsBytes(row); shouldWriteHeader = false; } else { bytes = writer.writeValueAsBytes(row); } write(bytes); }
@Override public void newTable(final String tableName, final List<ColumnInfo> columnsForTable) { currentTableName = tableName; final CsvSchema.Builder builder = CsvSchema.builder(); // Remove quoting of character which applies (somewhat arbitrarily, Tatu???) for string whose length is greater than MAX_QUOTE_CHECK = 24 -- See CVSWriter#_mayNeedQuotes builder.disableQuoteChar(); builder.setColumnSeparator('|'); for (final ColumnInfo columnInfo : columnsForTable) { builder.addColumn(columnInfo.getColumnName(), getColumnTypeFromSqlType(columnInfo.getDataType())); } currentCSVSchema = builder.build(); writer = mapper.writer(currentCSVSchema); shouldWriteHeader = true; }
public CsvConverter(File csvDir, List<File> inputFiles) { this.csvDir = csvDir; this.inputFiles = inputFiles; csvMapper.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false); schema = csvMapper.schemaFor(Comment.class); schema.withColumnSeparator('\t'); schema.withHeader(); }
private MappingIterator<CsvMapperData> readValues(byte[] csvContent) throws TermCsvLoaderException { CsvMapper csvMapper = new CsvMapper(); CsvSchema csvSchema = csvMapper.schemaFor(CsvMapperData.class). withColumnSeparator(CSV_SEPARATOR). withSkipFirstDataRow(true).withHeader(). withoutColumns(); ObjectReader objectReader = csvMapper.reader(CsvMapperData.class).with(csvSchema); try { return objectReader.readValues(csvContent); } catch (IOException e) { throw new TermCsvLoaderException(e); } } }
private static <T> List<T> importCsvRules(Class<T> type, Class<?> mixin, String rulesString) throws Exception { CsvSchema csvSchema = CsvSchema.emptySchema().withHeader().withColumnSeparator(';'); CsvMapper mapper = new CsvMapper(); mapper.addMixIn(type, mixin); mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT); mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true); MappingIterator<T> readValues = mapper.readerFor(type).with(csvSchema).readValues(rulesString); return readValues.readAll(); }
/** * Convenience method that is same as *<pre> * CsvSchema.emptySchema().withHeader(); *</pre> * and returns a {@link CsvSchema} instance that uses default configuration * with additional setting that the first content line contains intended * column names. */ public CsvSchema schemaWithHeader() { return CsvSchema.emptySchema().withHeader(); }
final Builder schemaBuilder = CsvSchema.builder(); ObjectWriter writer = mapper.writer(schema.withHeader().withColumnSeparator('\t')); writer.writeValue(output.getBody(), results);
for (int i = 0; i < itemList.size(); i++) { if (i == 0) { schema = schema.withHeader(); } else { schema = schema.withoutHeader(); .withColumnSeparator(delimiter) .withoutQuoteChar() .withLineSeparator(lineSep)).writeValueAsString(itemList.get(i));
private MappingIterator<TruckEvent> readTruckEventsFromCsv(InputStream csvStream) throws IOException { CsvSchema bootstrap = CsvSchema.builder() // driverId,truckId,eventTime,eventType,longitude,latitude,eventKey,correlationId,driverName,routeId,routeName,eventDate .addColumn("driverId", CsvSchema.ColumnType.NUMBER) .addColumn("truckId", CsvSchema.ColumnType.NUMBER) .addColumn("eventTime", CsvSchema.ColumnType.STRING) .addColumn("eventType", CsvSchema.ColumnType.STRING) .addColumn("longitude", CsvSchema.ColumnType.NUMBER) .addColumn("latitude", CsvSchema.ColumnType.NUMBER) .addColumn("eventKey", CsvSchema.ColumnType.STRING) .addColumn("correlationId", CsvSchema.ColumnType.NUMBER) .addColumn("driverName", CsvSchema.ColumnType.STRING) .addColumn("routeId", CsvSchema.ColumnType.NUMBER) .addColumn("routeName", CsvSchema.ColumnType.STRING) .addColumn("eventDate", CsvSchema.ColumnType.STRING) // .addColumn("miles", CsvSchema.ColumnType.NUMBER) .build().withHeader(); CsvMapper csvMapper = new CsvMapper(); return csvMapper.readerFor(TruckEvent.class).with(bootstrap).readValues(csvStream); }
public static final synchronized <T> String serialize(final T object, final Boolean withHeaders) throws IOException { CsvMapper csvMapper = new CsvMapper(); CsvSchema csvSchema = csvMapper.schemaFor(object.getClass()); if (withHeaders) { csvSchema = csvSchema.withHeader(); } else { csvSchema = csvSchema.withoutHeader(); } return csvMapper.writer(csvSchema).writeValueAsString(object); }
users.add(user2); CsvSchema schema = CsvSchema.builder() .addColumn("firstName") .addColumn("lastName") mapper.enable(CsvParser.Feature.WRAP_AS_ARRAY); ObjectWriter writer = mapper.writer(schema.withLineSeparator("\n")); try { writer.writeValue(new File("target/ModifiedUsers.csv"), users);
/** * Create a new iterator from the given reader. * * @param csvReader A reader of CSV rows. */ public InnerRowIterator(final Reader csvReader) { // Construct our schema. CsvSchema schema = CsvSchema.emptySchema().withUseHeader(true); CsvMapper mapper = new CsvMapper(); TypeReference<LinkedHashMap<String, Object>> typeRef = new TypeReference<LinkedHashMap<String, Object>>() { }; try { ObjectReader reader = mapper.reader(schema).withType(typeRef); innerIterator = reader.readValues(csvReader); } catch (IOException ioe) { logger.error("CSV File does not exist."); } }
/** * Initialize an ObjectReader that does not quote things. * * @return an initialized ObjectReader */ protected static ObjectReader initRaw() { return init(CsvSchema.emptySchema().withoutQuoteChar()); }
/** * Convenience method that is same as *<pre> * CsvSchema.emptySchema() *</pre> * that is, returns an "empty" Schema; one with default values and no * column definitions. */ public CsvSchema schema() { return CsvSchema.emptySchema(); }
@Override public void write( ApiRequest request, ResponseData responseData, OutputStream outputStream ) throws IOException { // Just write the header first CsvSchema schema = buildCsvHeaders(responseData); CsvMapper csvMapper = objectMappers.getCsvMapper(); csvMapper.writer().with(schema.withSkipFirstDataRow(true)) .writeValue(outputStream, Collections.emptyMap()); ObjectWriter writer = csvMapper.writer().with(schema.withoutHeader()); try { responseData.getResultSet().stream() .map(responseData::buildResultRow) .forEachOrdered( row -> { try { writer.writeValue(outputStream, row); } catch (IOException ioe) { String msg = String.format("Unable to write CSV data row: %s", row); LOG.error(msg, ioe); throw new RuntimeException(msg, ioe); } } ); } catch (RuntimeException re) { throw new IOException(re); } }
/** * Helper method for construcing and returning schema instance that * is similar to this one, except that it will not be using header line. */ public CsvSchema withoutHeader() { return withUseHeader(false); }
.with( CSV_SCHEMA.withSkipFirstDataRow( skipFirst ) );
/** * 序列化为CSV */ public static <V> String toCsv(String separator, V v) { try { CsvSchema schema = csvMapper.schemaFor(v.getClass()).withHeader().withColumnSeparator(separator.charAt(0)); return csvMapper.writer(schema).writeValueAsString(v); } catch (JsonProcessingException e) { log.error("jackson to csv error, obj: {}", v, e); return null; } }
private MappingIterator<CsvMapperData> readValues(byte[] csvContent) throws ReferenceCsvLoaderException { CsvMapper csvMapper = new CsvMapper(); CsvSchema csvSchema = csvMapper.schemaFor(CsvMapperData.class). withColumnSeparator(CSV_SEPARATOR). withSkipFirstDataRow(true).withHeader(). withoutColumns(); ObjectReader objectReader = csvMapper.reader(CsvMapperData.class).with(csvSchema); try { return objectReader.readValues(csvContent); } catch (IOException e) { throw new ReferenceCsvLoaderException(e); } } }
try { char separator = computeSeparator(file); CsvSchema schema = CsvSchema.emptySchema().withHeader().withColumnSeparator(separator); try (FileReader fr = new FileReader(file); BufferedReader reader = new BufferedReader(fr, DEFAULT_BUFFER_SIZE)) {