public void loadData() {
SimpleDateFormat formatIn = new SimpleDateFormat("MMMM d, yyyy");
SimpleDateFormat formatOut = new SimpleDateFormat("MM/d/yy");
ObjectMapper objectMapper = new ObjectMapper();
JsonFactory jsonFactory = new JsonFactory();
Random random = new Random();
try {
JsonParser jsonParserBlog =
jsonFactory.createParser(getResources().openRawResource(R.raw.blog));
List<Blog> entries =
objectMapper.readValue(jsonParserBlog, new TypeReference<List<Blog>>() {});
JsonParser jsonParserEmoji =
jsonFactory.createParser(getResources().openRawResource(R.raw.emoji));
List<String> emojies =
objectMapper.readValue(jsonParserEmoji, new TypeReference<List<String>>() {});
int numEmoji = emojies.size();
for (Blog blog : entries) {
blog.setEmoji(emojies.get(random.nextInt(numEmoji)));
try {
blog.setDate(formatOut.format(formatIn.parse(blog.getDate())));
} catch (ParseException e) {
e.printStackTrace();
}
}
Realm realm = Realm.getInstance(this);
realm.beginTransaction();
realm.copyToRealm(entries);
realm.commitTransaction();
realm.close();
} catch (Exception e) {
throw new IllegalStateException("Could not load blog data.");
}
}
// And then one more test just for Bytes-based symbol table
public void testByteBasedSymbolTable() throws Exception {
// combination of short, medium1/2, long names...
final String JSON =
aposToQuotes(
"{'abc':1, 'abc\\u0000':2, '\\u0000abc':3, "
// then some medium
+ "'abc123':4,'abcd1234':5,"
+ "'abcd1234a':6,'abcd1234abcd':7,"
+ "'abcd1234abcd1':8"
+ "}");
JsonFactory f = new JsonFactory();
JsonParser p = f.createParser(JSON.getBytes("UTF-8"));
ByteQuadsCanonicalizer symbols = _findSymbols(p);
assertEquals(0, symbols.size());
_streamThrough(p);
assertEquals(8, symbols.size());
p.close();
// and, for fun, try again
p = f.createParser(JSON.getBytes("UTF-8"));
_streamThrough(p);
symbols = _findSymbols(p);
assertEquals(8, symbols.size());
p.close();
p = f.createParser(JSON.getBytes("UTF-8"));
_streamThrough(p);
symbols = _findSymbols(p);
assertEquals(8, symbols.size());
p.close();
}
/** @see com.amazonaws.http.HttpResponseHandler#handle(com.amazonaws.http.HttpResponse) */
public AmazonWebServiceResponse<T> handle(HttpResponse response) throws Exception {
log.trace("Parsing service response JSON");
String CRC32Checksum = response.getHeaders().get("x-amz-crc32");
CRC32ChecksumCalculatingInputStream crc32ChecksumInputStream = null;
JsonParser jsonParser = null;
if (!needsConnectionLeftOpen) {
if (CRC32Checksum != null) {
crc32ChecksumInputStream = new CRC32ChecksumCalculatingInputStream(response.getContent());
jsonParser = jsonFactory.createParser(crc32ChecksumInputStream);
} else {
jsonParser = jsonFactory.createParser(response.getContent());
}
}
try {
AmazonWebServiceResponse<T> awsResponse = new AmazonWebServiceResponse<T>();
JsonUnmarshallerContext unmarshallerContext =
new JsonUnmarshallerContext(jsonParser, response);
registerAdditionalMetadataExpressions(unmarshallerContext);
T result = responseUnmarshaller.unmarshall(unmarshallerContext);
if (CRC32Checksum != null) {
long serverSideCRC = Long.parseLong(CRC32Checksum);
long clientSideCRC = crc32ChecksumInputStream.getCRC32Checksum();
if (clientSideCRC != serverSideCRC) {
throw new CRC32MismatchException(
"Client calculated crc32 checksum didn't match that calculated by server side");
}
}
awsResponse.setResult(result);
Map<String, String> metadata = unmarshallerContext.getMetadata();
metadata.put(ResponseMetadata.AWS_REQUEST_ID, response.getHeaders().get("x-amzn-RequestId"));
awsResponse.setResponseMetadata(new ResponseMetadata(metadata));
log.trace("Done parsing service response");
return awsResponse;
} finally {
if (!needsConnectionLeftOpen) {
try {
jsonParser.close();
} catch (IOException e) {
log.warn("Error closing json parser", e);
}
}
}
}
// [core#191]: similarly, but for "short" symbols:
public void testShortNameCollisionsViaParser() throws Exception {
JsonFactory f = new JsonFactory();
String json = _shortDoc191();
JsonParser p;
// First: ensure that char-based is fine
p = f.createParser(json);
while (p.nextToken() != null) {}
p.close();
// and then that byte-based
p = f.createParser(json.getBytes("UTF-8"));
while (p.nextToken() != null) {}
p.close();
}
/** @param bioID */
private boolean setBioID(String bioID) {
boolean toRet = false;
try {
JsonFactory factory = new JsonFactory();
JsonParser jparser = factory.createParser(bioID);
String key = "";
// Get StartObject for JSON, after first {
jparser.nextToken();
while (jparser.nextToken() != JsonToken.END_OBJECT) {
key = jparser.getText();
if (key.equals("id")) {
key = jparser.nextTextValue();
// Set bioID in Experiment
selExp.setBioID(key);
toRet = true;
} else {
jparser.skipChildren();
}
}
jparser.close();
} catch (JsonParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return toRet;
}
public void testUtf8Issue462() throws Exception {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
IOContext ioc = new IOContext(new BufferRecycler(), bytes, true);
JsonGenerator gen = new UTF8JsonGenerator(ioc, 0, null, bytes);
String str = "Natuurlijk is alles gelukt en weer een tevreden klant\uD83D\uDE04";
int length = 4000 - 38;
for (int i = 1; i <= length; ++i) {
gen.writeNumber(1);
}
gen.writeString(str);
gen.flush();
gen.close();
// Also verify it's parsable?
JsonFactory f = new JsonFactory();
JsonParser p = f.createParser(bytes.toByteArray());
for (int i = 1; i <= length; ++i) {
assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
assertEquals(1, p.getIntValue());
}
assertToken(JsonToken.VALUE_STRING, p.nextToken());
assertEquals(str, p.getText());
assertNull(p.nextToken());
p.close();
}
/**
* Constructs a configuration file from a past configuration file that was saved to the disk.
*
* @param fileName - the path to the file on disk
* @throws IOException - if there is any problem reading the file
*/
public Configuration(final String fileName) throws IOException {
final JsonFactory jf = new JsonFactory();
final JsonParser jp = jf.createParser(new File(fileName));
jp.nextToken();
while (jp.nextToken() != JsonToken.END_OBJECT) {
final String fieldName = jp.getCurrentName();
jp.nextToken();
switch (fieldName) {
case IN_FILE_KEY:
this.inputFileName = jp.getText();
break;
case IN_FILE_DIR_KEY:
this.inputFileDirName = jp.getText();
break;
case SPLIT_PATTERN_KEY:
this.splitPattern = jp.getText();
break;
case OUT_FILE_KEY:
this.outDirName = jp.getText();
break;
case EXEC_LOC_KEY:
this.execPath = jp.getText();
break;
case NUM_PROCESSES_KEY:
this.numberOfThreads = jp.getIntValue();
break;
case STATS_KEY:
this.makeStats = jp.getBooleanValue();
break;
case NUM_HEADER_KEY:
this.numberOfHeaderLines = jp.getIntValue();
break;
case DEFAULT_MERGE_KEY:
if (jp.getBooleanValue()) {
this.mergeMethod = 0;
}
break;
case CUSTOM_MERGE_KEY:
if (jp.getBooleanValue()) {
this.mergeMethod = 1;
}
break;
case EXTERNAL_MERGE_KEY:
if (jp.getBooleanValue()) {
this.mergeMethod = 2;
}
break;
case ARGUMENT_KEY:
this.argument = jp.getText();
break;
case OUTPUT_FMT_KEY:
this.outputFmt = jp.getBooleanValue();
break;
default:
assert (false);
}
}
jp.close();
}
private <T> String processData(
final CrestApiProcessor<T> processor, final CrestContainer<T> container, final String data) {
String next = null;
try {
final JsonFactory parserFactory = new JsonFactory();
final JsonParser jsonParser = parserFactory.createParser(data);
jsonParser.nextToken();
while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
final String fieldname = jsonParser.getCurrentName();
jsonParser.nextToken();
switch (fieldname) {
case "totalCount":
container.setTotalCount(jsonParser.getIntValue());
break;
case "pageCount":
container.setPageCount(jsonParser.getIntValue());
break;
case "items":
processItems(processor, container, jsonParser);
break;
case "next":
next = processNext(jsonParser);
break;
default:
break;
}
}
} catch (final IOException e) {
if (LOGGER.isWarnEnabled()) {
LOGGER.warn("Problems while parsing json data: " + e.getMessage(), e);
}
}
return next;
}
private void parseItemIdList(Reader in, IItemIdListHandler handler)
throws JsonParseException, IOException, RemoteException {
JsonFactory f = new JsonFactory();
JsonParser jp = f.createParser(in);
String currName;
List<String> idList = new ArrayList<String>();
jp.nextToken(); // will return JsonToken.START_OBJECT (verify?)
while (jp.nextToken() != JsonToken.END_OBJECT) {
currName = jp.getCurrentName();
jp.nextToken(); // move to value, or START_OBJECT/START_ARRAY
if (currName.equals("itemRefs")) { // contains an object
// start items
while (jp.nextToken() != JsonToken.END_ARRAY) {
currName = jp.getCurrentName();
if (currName == null) continue;
jp.nextToken();
if (currName.equals("id")) {
idList.add(Utils.dec2Hex(jp.getText())); // convert dec to hex
} else {
jp.skipChildren();
}
}
handler.items(idList);
} else {
jp.skipChildren();
}
}
}
/** Parse a JSON string that represents a ClusterCommand.. */
public static EncryptedCommand parseCommandString(String commandString) {
try {
JsonFactory jsonFact = new JsonFactory();
JsonParser jsonParser = jsonFact.createParser(commandString);
return new ObjectMapper().readValue(jsonParser, EncryptedCommand.class);
} catch (IOException e) {
LOGGER.warn(null, e);
return null;
}
}
public void parseFromStringAndNotClose(JsonFactory factory) throws IOException {
UTF8StreamJsonParser parser = null;
try {
parser = (UTF8StreamJsonParser) factory.createParser("[]");
Object o = parser.readValueAs(Object.class);
ignore(o);
} catch (Exception e) {
} finally {
}
}
private static JsonParser createJsonParserFromStream(final InputStream streamRef)
throws JsonParseException, IOException {
JsonParser parser = jsonFactory.createParser(streamRef);
return parser
// allows handling of infinity, -infinity, and NaN for Doubles
.enable(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS)
// don't close the stream and allow it to be drained completely
// in ExecutionEngine to improve socket reuse
.disable(JsonParser.Feature.AUTO_CLOSE_SOURCE);
}
private void parseTagList(Reader in, ITagListHandler handler)
throws JsonParseException, IOException, RemoteException {
JsonFactory f = new JsonFactory();
JsonParser jp = f.createParser(in);
String currName;
ITag tag = null;
List<ITag> tagList = new ArrayList<ITag>();
jp.nextToken(); // will return JsonToken.START_OBJECT (verify?)
while (jp.nextToken() != JsonToken.END_OBJECT) {
currName = jp.getCurrentName();
jp.nextToken(); // move to value, or START_OBJECT/START_ARRAY
if (currName.equals("tags")) { // contains an object
// start items
while (jp.nextToken() != JsonToken.END_ARRAY) {
if (jp.getCurrentToken() == JsonToken.START_OBJECT) {
tag = new ITag();
} else if (jp.getCurrentToken() == JsonToken.END_OBJECT) {
tagList.add(tag);
tag = null;
}
currName = jp.getCurrentName();
if (currName == null) continue;
jp.nextToken();
if (currName.equals("id")) {
tag.uid = jp.getText();
int i = tag.uid.indexOf("/label/");
if (i != -1) {
tag.label = tag.uid.substring(i + "/label/".length());
// NOTE: @see ReaderManager#updateTagTypes
tag.type = ITag.TYPE_TAG_LABEL;
} else if (tag.uid.endsWith("state/com.google/starred")) {
tag.label = "state/com.google/starred";
tag.type = ITag.TYPE_TAG_STARRED;
}
} else if (currName.equals("sortid")) {
tag.sortid = jp.getText();
} else {
jp.skipChildren();
}
}
handler.tags(tagList);
} else {
jp.skipChildren();
}
}
}
public void parseFromInputStreamAndLeak(JsonFactory factory) throws IOException {
JsonParser parser = null;
FileInputStream in = null;
try {
in = new FileInputStream("");
parser = factory.createParser(in);
Object o = parser.readValueAs(Object.class);
ignore(o);
} catch (Exception e) {
} finally {
if (parser != null) parser.close();
}
// parser does not own a resource which is leaked
}
private void _testSurrogates(JsonFactory f, boolean checkText) throws IOException {
byte[] json = "{\"text\":\"\uD83D\uDE03\"}".getBytes("UTF-8");
// first
JsonParser jp = f.createParser(json);
assertToken(JsonToken.START_OBJECT, jp.nextToken());
assertToken(JsonToken.FIELD_NAME, jp.nextToken());
if (checkText) {
assertEquals("text", jp.getText());
}
assertToken(JsonToken.VALUE_STRING, jp.nextToken());
if (checkText) {
assertEquals("\uD83D\uDE03", jp.getText());
}
assertToken(JsonToken.END_OBJECT, jp.nextToken());
}
private Map<String, Long> parseUnreadCountList(Reader in) throws JsonParseException, IOException {
JsonFactory f = new JsonFactory();
JsonParser jp = f.createParser(in);
String currName;
String uid = null;
Long timestamp = null;
int len;
String text = null;
Map<String, Long> unreadList = new HashMap<String, Long>();
jp.nextToken(); // will return JsonToken.START_OBJECT (verify?)
while (jp.nextToken() != JsonToken.END_OBJECT) {
currName = jp.getCurrentName();
jp.nextToken(); // move to value, or START_OBJECT/START_ARRAY
if (currName.equals("unreadcounts")) { // contains an object
// start items
while (jp.nextToken() != JsonToken.END_ARRAY) {
if (jp.getCurrentToken() == JsonToken.START_OBJECT) {
// do nothing
} else if (jp.getCurrentToken() == JsonToken.END_OBJECT) {
if (!unreadList.containsKey(uid)) unreadList.put(uid, timestamp);
}
currName = jp.getCurrentName();
if (currName == null) continue;
jp.nextToken();
if (currName.equals("id")) {
uid = jp.getText();
} else if (currName.equals("newestItemTimestampUsec")) {
text = jp.getText();
len = text.length();
if (len > 13) text = jp.getText().substring(0, jp.getText().length() - 6);
else if (len > 10) text = jp.getText().substring(0, jp.getText().length() - 3);
timestamp = Utils.asLong(text); // millis -> unixtime
} else {
jp.skipChildren();
}
}
} else {
jp.skipChildren();
}
}
return unreadList;
}
protected final double _testRawDeser(int reps, byte[] json, ObjectReader reader)
throws IOException {
long start = System.nanoTime();
final JsonFactory f = reader.getFactory();
while (--reps >= 0) {
JsonParser p = f.createParser(new ByteArrayInputStream(json));
JsonToken t;
while ((t = p.nextToken()) != null) {
if (t == JsonToken.VALUE_STRING) {
p.getText();
} else if (t.isNumeric()) {
p.getNumberValue();
}
;
}
p.close();
}
hash = f.hashCode();
return _msecsFromNanos(System.nanoTime() - start);
}
@Override
protected Void doInBackground(String... urls) {
locationsList = new ArrayList<>();
final JsonFactory jfactory = new JsonFactory();
JsonParser jParser = null;
try {
jParser = jfactory.createParser(new URL(urls[0]));
Log.d("MyLogs", "URL - " + urls[0]);
while (jParser.nextToken() != JsonToken.END_ARRAY) {
String fieldname = jParser.getCurrentName();
if ("id".equals(fieldname)) {
map = new HashMap<>();
jParser.nextToken();
map.put("id", jParser.getText());
} else if ("name".equals(fieldname)) {
jParser.nextToken();
map.put("name", jParser.getText());
locationsList.add(map);
}
}
} catch (IOException | RuntimeException e) {
e.printStackTrace();
} finally {
if (jParser != null) {
try {
jParser.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
list = new ArrayList<>();
for (HashMap<String, String> a : locationsList) {
list.add(a.get("name"));
}
return null;
}
public XContentParser createParser(InputStream is) throws IOException {
return new JsonXContentParser(jsonFactory.createParser(is));
}
public XContentParser createParser(String content) throws IOException {
return new JsonXContentParser(jsonFactory.createParser(new FastStringReader(content)));
}
private String parseItemList(Reader in, IItemListHandler handler)
throws JsonParseException, IOException, RemoteException {
JsonFactory f = new JsonFactory();
JsonParser jp = f.createParser(in);
long length = 0;
String currName;
String mediaUrl = null;
String mediaType = null;
IItem entry = null;
String continuation = null;
List<IItem> itemList = new ArrayList<IItem>();
List<String> excludedSubs = handler.excludedStreams(); // excluded subscriptions
jp.nextToken(); // will return JsonToken.START_OBJECT (verify?)
while (jp.nextToken() != JsonToken.END_OBJECT) {
currName = jp.getCurrentName();
jp.nextToken(); // move to value, or START_OBJECT/START_ARRAY
if ("continuation".equals(currName)) {
continuation = jp.getText();
} else if ("items".equals(currName)) { // contains an object
// start items
while (jp.nextToken() != JsonToken.END_ARRAY) {
// request stop
// if (handler.requestStop()) throw new JsonParseException(null, null);
if (jp.getCurrentToken() == JsonToken.START_OBJECT) {
entry = new IItem();
} else if (jp.getCurrentToken() == JsonToken.END_OBJECT) {
if (entry != null && entry.uid.length() > 0) {
if (length + entry.getLength() > MAX_TRANSACTION_LENGTH) {
handler.items(itemList, STRATEGY_INSERT_DEFAULT);
itemList.clear();
length = 0;
}
itemList.add(entry);
length += entry.getLength();
}
if (itemList.size() % 200 == 0
|| length
> MAX_TRANSACTION_LENGTH) { // avoid TransactionTooLargeException, android only
// allows 1mb
handler.items(itemList, STRATEGY_INSERT_DEFAULT);
itemList.clear();
length = 0;
}
entry = null;
}
currName = jp.getCurrentName();
if (currName == null || entry == null) continue;
jp.nextToken(); // move to value
if (currName.equals("id")) {
entry.uid = stripItemUid(jp.getText());
} else if (currName.equals("crawlTimeMsec")) {
entry.updatedTime = Long.valueOf(jp.getText()) / 1000;
} else if (currName.equals("title")) {
entry.title = Utils.stripTags(unEscapeEntities(jp.getText()), true);
} else if (currName.equals("categories")) {
while (jp.nextToken() != JsonToken.END_ARRAY) {
String category = jp.getText();
if (category != null && addUserLabel(category, entry)) {
entry.addTag(category);
}
if (category != null && category.endsWith("/state/com.google/read")) {
entry.read = true;
}
}
} else if (currName.equals("published")) {
entry.publishedTime = jp.getLongValue();
} else if (currName.equals("alternate")) {
while (jp.nextToken() != JsonToken.END_ARRAY) {
currName = jp.getCurrentName();
if (currName == null) continue;
jp.nextToken();
if (currName.equals("href")) {
entry.link = jp.getText();
} else {
jp.skipChildren();
}
}
} else if (currName.equals("enclosure")) {
while (jp.nextToken() != JsonToken.END_ARRAY) {
currName = jp.getCurrentName();
if (currName == null) continue;
jp.nextToken();
if (currName.equals("href")) {
mediaUrl = jp.getText();
} else if (currName.equals("type")) {
mediaType = jp.getText();
if (mediaType.startsWith("image")) {
entry.addImage(mediaUrl, mediaType);
} else if (mediaType.startsWith("video")) {
entry.addVideo(mediaUrl, mediaType);
} else if (mediaType.startsWith("audio")) {
entry.addAudio(mediaUrl, mediaType);
}
mediaUrl = null;
mediaType = null;
} else {
jp.skipChildren();
}
}
} else if (currName.equals("summary") || currName.equals("content")) {
while (jp.nextToken() != JsonToken.END_OBJECT) {
currName = jp.getCurrentName();
if (currName == null) continue;
jp.nextToken();
if (currName.equals("content")) {
entry.content = unEscapeEntities(jp.getText());
} else {
jp.skipChildren();
}
}
} else if (currName.equals("author")) {
entry.author = jp.getText();
} else if (currName.equals("origin")) {
while (jp.nextToken() != JsonToken.END_OBJECT) {
currName = jp.getCurrentName();
if (currName == null) continue;
jp.nextToken();
if (currName.equals("streamId")) {
String streamId = jp.getText();
if (streamId != null
&& (excludedSubs == null || !excludedSubs.contains(streamId))) {
entry.subUid = streamId;
} else entry = null;
} else {
jp.skipChildren();
}
}
} else {
jp.skipChildren();
}
}
handler.items(itemList, STRATEGY_INSERT_DEFAULT);
itemList.clear();
} else {
jp.skipChildren();
}
}
return continuation;
}
public XContentParser createParser(byte[] data) throws IOException {
return new JsonXContentParser(jsonFactory.createParser(data));
}
private void parseSubList(
Reader in, ISubscriptionListHandler handler, Map<String, Long> updatedTimes)
throws JsonParseException, IOException, RemoteException {
JsonFactory f = new JsonFactory();
JsonParser jp = f.createParser(in);
String currName;
ISubscription feed = null;
List<ISubscription> feedList = new ArrayList<ISubscription>();
jp.nextToken(); // will return JsonToken.START_OBJECT (verify?)
while (jp.nextToken() != JsonToken.END_OBJECT) {
currName = jp.getCurrentName();
jp.nextToken(); // move to value, or START_OBJECT/START_ARRAY
if (currName.equals("subscriptions")) { // contains an object
// start items
while (jp.nextToken() != JsonToken.END_ARRAY) {
if (jp.getCurrentToken() == JsonToken.START_OBJECT) {
feed = new ISubscription();
} else if (jp.getCurrentToken() == JsonToken.END_OBJECT) {
if (updatedTimes != null && updatedTimes.containsKey(feed.uid))
feed.newestItemTime = updatedTimes.get(feed.uid);
feedList.add(feed);
feed = null;
}
currName = jp.getCurrentName();
if (currName == null) continue;
jp.nextToken();
if (currName.equals("id")) {
feed.uid = jp.getText();
} else if (currName.equals("title")) {
feed.title = unEscapeEntities(jp.getText());
} else if (currName.equals("sortid")) {
feed.sortid = jp.getText();
} else if (currName.equals("htmlUrl")) {
feed.htmlUrl = jp.getText();
} else if (currName.equals("categories")) {
while (jp.nextToken() != JsonToken.END_ARRAY) {
currName = jp.getCurrentName();
if (currName == null) continue;
jp.nextToken();
if (currName.equals("id")) {
feed.addTag(jp.getText());
} else {
jp.skipChildren();
}
}
} else {
jp.skipChildren();
}
}
handler.subscriptions(feedList);
} else {
jp.skipChildren();
}
}
}
public XContentParser createParser(Reader reader) throws IOException {
return new JsonXContentParser(jsonFactory.createParser(reader));
}
public static void main(String[] args)
throws JsonParseException, MalformedURLException, IOException, ClassNotFoundException,
SQLException, JSONException {
Class.forName("org.h2.Driver");
Connection conn = DriverManager.getConnection("jdbc:h2:~/stories2009-2014", "sa", "");
// add application code here
Statement statement = conn.createStatement();
statement.execute("drop table story IF EXISTS;");
statement.execute(
"create table story("
+ "id int primary key,"
+ " title varchar(255),"
+ " url varchar(255),"
+ " localDate date,"
+ " primaryImage varchar(255),"
+ " primaryImageCaption TEXT,"
+ " primaryImageRightsInformation TEXT,"
+ " subjects TEXT,"
+ " station varchar(255),"
+ " state varchar(255),"
+ " place varchar(255),"
+ " keywords TEXT,"
+ " latitude varchar(255),"
+ " longitude varchar(255),"
+ " mediaRSS varchar(255))");
statement.close();
String fileJson = "Localphotostories2009-2014-JSON.json";
JsonFactory factory = new JsonFactory();
JsonParser parser = factory.createParser(new File(fileJson));
int idx = 1;
while (parser.nextToken() != JsonToken.END_ARRAY) {
while (parser.nextToken() != JsonToken.END_OBJECT) {
if (parser.getCurrentToken() == JsonToken.START_OBJECT) continue;
parser.nextToken();
String title = parser.getText();
parser.nextToken();
parser.nextToken();
String url = parser.getText();
parser.nextToken();
parser.nextToken();
String date = parser.getText();
DateTimeFormatter pattern = DateTimeFormatter.ofPattern("d/M/yyyy");
LocalDate localDate = LocalDate.parse(date, pattern);
parser.nextToken();
parser.nextToken();
String primaryImage = parser.getText();
parser.nextToken();
parser.nextToken();
String primaryImageCaption = parser.getText();
parser.nextToken();
parser.nextToken();
String primaryImageRightsInformation = parser.getText();
parser.nextToken();
parser.nextToken();
String subjects = parser.getText();
parser.nextToken();
parser.nextToken();
String station = parser.getText();
parser.nextToken();
parser.nextToken();
String state = parser.getText();
parser.nextToken();
parser.nextToken();
String place = parser.getText();
parser.nextToken();
parser.nextToken();
String keywords = parser.getText();
parser.nextToken();
parser.nextToken();
String latitude = parser.getText();
parser.nextToken();
parser.nextToken();
String longitude = parser.getText();
parser.nextToken();
parser.nextToken();
String mediaRSS = parser.getText();
if (latitude.isEmpty() && longitude.isEmpty()) continue;
Statement cooridinate = conn.createStatement();
ResultSet resultSet =
cooridinate.executeQuery(
"SELECT id From story where latitude = '"
+ latitude
+ "' and longitude = '"
+ longitude
+ "'");
while (resultSet.next()) {
int id = resultSet.getInt(1);
Double tempLatitude = Double.valueOf(latitude);
tempLatitude += Math.random() / 100;
Double tempLongitude = Double.valueOf(longitude);
tempLongitude += Math.random() / 100;
Statement updatestat = conn.createStatement();
updatestat.executeUpdate(
"UPDATE story set latitude = '"
+ tempLatitude
+ "', longitude = '"
+ tempLongitude
+ "' where id = "
+ id);
updatestat.close();
}
cooridinate.close();
PreparedStatement stm =
conn.prepareStatement(
"insert into story(id,"
+ " title,"
+ " url,"
+ " localDate,"
+ " primaryImage,"
+ " primaryImageCaption,"
+ " primaryImageRightsInformation,"
+ " subjects,"
+ " station,"
+ " state,"
+ " place,"
+ " keywords,"
+ " latitude,"
+ " longitude,"
+ " mediaRSS) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
stm.setInt(1, idx++);
stm.setString(2, title);
stm.setString(3, url);
java.util.Date from = Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
stm.setDate(4, new Date(from.getTime()));
stm.setString(5, primaryImage);
stm.setString(6, primaryImageCaption);
stm.setString(7, primaryImageRightsInformation);
stm.setString(8, subjects);
stm.setString(9, station);
stm.setString(10, state);
stm.setString(11, place);
stm.setString(12, keywords);
stm.setString(13, latitude);
stm.setString(14, longitude);
stm.setString(15, mediaRSS);
stm.execute();
stm.close();
}
}
// Ballarat photographs data
fileJson = "BallaratPhotographics.json";
factory = new JsonFactory();
parser = factory.createParser(new File(fileJson));
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JsonOrgModule());
JSONArray value = mapper.readValue(parser, JSONArray.class);
for (int i = 0; i < value.length(); i++) {
String title = value.getJSONObject(i).getString("FIELD1");
PreparedStatement stm =
conn.prepareStatement(
"insert into story(id,"
+ " title,"
+ " url,"
+ " localDate,"
+ " primaryImage,"
+ " primaryImageCaption,"
+ " primaryImageRightsInformation,"
+ " subjects,"
+ " station,"
+ " state,"
+ " place,"
+ " keywords,"
+ " latitude,"
+ " longitude,"
+ " mediaRSS) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
stm.setInt(1, idx++);
stm.setString(2, value.getJSONObject(i).getString("FIELD1"));
stm.setString(3, value.getJSONObject(i).getString("FIELD4"));
java.util.Date from = Date.valueOf(value.getJSONObject(i).getString("FIELD5") + "-01-01");
stm.setDate(4, new Date(from.getTime()));
stm.setString(5, value.getJSONObject(i).getString("FIELD3"));
stm.setString(6, value.getJSONObject(i).getString("FIELD2"));
stm.setString(7, "");
stm.setString(8, "");
stm.setString(9, "");
stm.setString(10, "VIC");
stm.setString(11, "Ballarat");
stm.setString(12, value.getJSONObject(i).getString("FIELD1"));
stm.setString(13, value.getJSONObject(i).getString("FIELD6"));
stm.setString(14, value.getJSONObject(i).getString("FIELD7"));
stm.setString(15, "BPHOTO");
stm.execute();
stm.close();
}
conn.close();
}
protected JsonParser constructParser(byte[] data) throws IOException {
return _factory.createParser(data, 0, data.length);
}
public XContentParser createParser(byte[] data, int offset, int length) throws IOException {
return new JsonXContentParser(jsonFactory.createParser(data, offset, length));
}
public void jsonParser() {
int iterator = 0;
Manager manager = Manager.getInstance(); // Create the object of singleton
Element jacksonElement = new Element();
JsonFactory jsonFactory = new JsonFactory();
try {
File f = new File(FileDownload.getFileName());
JsonParser parser = jsonFactory.createParser(f);
// Parse the file by Jackson parser
while (!parser.isClosed()) {
JsonToken jsonToken = parser.nextToken();
if (JsonToken.FIELD_NAME.equals(jsonToken)) {
String fieldName = parser.getCurrentName();
jsonToken = parser.nextToken();
// The JSON file has the next fields:
// location,date,name and object stock (this object
// includes:name,bid,id,visible,minPrice,maxPrice)
if ("location".equals(fieldName)) {
manager.setLocation(parser.getValueAsString());
}
if ("date".equals(fieldName)) {
manager.setDate(parser.getValueAsString());
}
if ("name".equals(fieldName) && (parser.getValueAsString().equals("Moscow Stock")))
manager.setName(parser.getValueAsString());
if ("bid".equals(fieldName)) {
jacksonElement.setBid(parser.getValueAsDouble());
iterator++;
} else if ("id".equals(fieldName)) {
jacksonElement.setId(parser.getValueAsInt());
iterator++;
} else if ("name".equals(fieldName)
&& (!parser.getValueAsString().equals("Moscow Stock"))) {
jacksonElement.setName(
parser.getValueAsString().substring(0, parser.getValueAsString().length() - 4));
iterator++;
} else if ("minPrice".equals(fieldName)) {
jacksonElement.setMinPrice(parser.getValueAsDouble());
iterator++;
} else if ("maxPrice".equals(fieldName)) {
jacksonElement.setMaxPrice(parser.getValueAsDouble());
iterator++;
} else if ("visible".equals(fieldName)) {
jacksonElement.setVisible(parser.getValueAsBoolean());
iterator++;
}
if (iterator == 6) {
manager.setJsonList(jacksonElement); // add the data to the list
jacksonElement = new Element();
iterator = 0;
}
}
}
} catch (JsonParseException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/** Parses the output of a {@code topN} query, sending the results to a {@link Sink}. */
private void parse(
QueryType queryType,
InputStream in,
Sink sink,
List<String> fieldNames,
List<ColumnMetaData.Rep> fieldTypes,
Page page) {
final JsonFactory factory = new JsonFactory();
final Row.RowBuilder rowBuilder = Row.newBuilder(fieldNames.size());
if (CalcitePrepareImpl.DEBUG) {
try {
final byte[] bytes = AvaticaUtils.readFullyToBytes(in);
System.out.println("Response: " + new String(bytes));
in = new ByteArrayInputStream(bytes);
} catch (IOException e) {
throw Throwables.propagate(e);
}
}
try (final JsonParser parser = factory.createParser(in)) {
switch (queryType) {
case TOP_N:
if (parser.nextToken() == JsonToken.START_ARRAY
&& parser.nextToken() == JsonToken.START_OBJECT) {
expectScalarField(parser, "timestamp");
if (parser.nextToken() == JsonToken.FIELD_NAME
&& parser.getCurrentName().equals("result")
&& parser.nextToken() == JsonToken.START_ARRAY) {
while (parser.nextToken() == JsonToken.START_OBJECT) {
// loop until token equal to "}"
parseFields(fieldNames, fieldTypes, rowBuilder, parser);
sink.send(rowBuilder.build());
rowBuilder.reset();
}
}
}
break;
case SELECT:
if (parser.nextToken() == JsonToken.START_ARRAY
&& parser.nextToken() == JsonToken.START_OBJECT) {
page.pagingIdentifier = null;
page.offset = -1;
expectScalarField(parser, "timestamp");
if (parser.nextToken() == JsonToken.FIELD_NAME
&& parser.getCurrentName().equals("result")
&& parser.nextToken() == JsonToken.START_OBJECT) {
if (parser.nextToken() == JsonToken.FIELD_NAME
&& parser.getCurrentName().equals("pagingIdentifiers")
&& parser.nextToken() == JsonToken.START_OBJECT) {
switch (parser.nextToken()) {
case FIELD_NAME:
page.pagingIdentifier = parser.getCurrentName();
if (parser.nextToken() == JsonToken.VALUE_NUMBER_INT) {
page.offset = parser.getIntValue();
}
expect(parser, JsonToken.END_OBJECT);
break;
case END_OBJECT:
}
}
if (parser.nextToken() == JsonToken.FIELD_NAME
&& parser.getCurrentName().equals("events")
&& parser.nextToken() == JsonToken.START_ARRAY) {
while (parser.nextToken() == JsonToken.START_OBJECT) {
expectScalarField(parser, "segmentId");
expectScalarField(parser, "offset");
if (parser.nextToken() == JsonToken.FIELD_NAME
&& parser.getCurrentName().equals("event")
&& parser.nextToken() == JsonToken.START_OBJECT) {
parseFields(fieldNames, fieldTypes, rowBuilder, parser);
sink.send(rowBuilder.build());
rowBuilder.reset();
}
expect(parser, JsonToken.END_OBJECT);
}
parser.nextToken();
}
}
}
break;
case GROUP_BY:
if (parser.nextToken() == JsonToken.START_ARRAY) {
while (parser.nextToken() == JsonToken.START_OBJECT) {
expectScalarField(parser, "version");
expectScalarField(parser, "timestamp");
if (parser.nextToken() == JsonToken.FIELD_NAME
&& parser.getCurrentName().equals("event")
&& parser.nextToken() == JsonToken.START_OBJECT) {
parseFields(fieldNames, fieldTypes, rowBuilder, parser);
sink.send(rowBuilder.build());
rowBuilder.reset();
}
expect(parser, JsonToken.END_OBJECT);
}
}
}
} catch (IOException | InterruptedException e) {
throw Throwables.propagate(e);
}
}
protected JsonParser constructParser(InputStream in) throws IOException {
return _factory.createParser(in);
}