diff --git a/jOOQ/src/main/java/org/jooq/LoaderJSONOptionsStep.java b/jOOQ/src/main/java/org/jooq/LoaderJSONOptionsStep.java
new file mode 100644
index 0000000000..5c24375731
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/LoaderJSONOptionsStep.java
@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2009-2013, Data Geekery GmbH (http://www.datageekery.com)
+ * All rights reserved.
+ *
+ * This work is dual-licensed
+ * - under the Apache Software License 2.0 (the "ASL")
+ * - under the jOOQ License and Maintenance Agreement (the "jOOQ License")
+ * =============================================================================
+ * You may choose which license applies to you:
+ *
+ * - If you're using this work with Open Source databases, you may choose
+ * either ASL or jOOQ License.
+ * - If you're using this work with at least one commercial database, you must
+ * choose jOOQ License
+ *
+ * For more information, please visit http://www.jooq.org/licenses
+ *
+ * Apache Software License 2.0:
+ * -----------------------------------------------------------------------------
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * jOOQ License and Maintenance Agreement:
+ * -----------------------------------------------------------------------------
+ * Data Geekery grants the Customer the non-exclusive, timely limited and
+ * non-transferable license to install and use the Software under the terms of
+ * the jOOQ License and Maintenance Agreement.
+ *
+ * This library is distributed with a LIMITED WARRANTY. See the jOOQ License
+ * and Maintenance Agreement for more details: http://www.jooq.org/licensing
+ */
+package org.jooq;
+
+/**
+ * The Loader API is used for configuring data loads.
+ *
+ * The step in constructing the {@link org.jooq.Loader} object where you can set the
+ * optional CSV loader options.
+ *
+ * @author Lukas Eder
+ */
+public interface LoaderJSONOptionsStep> extends LoaderLoadStep {
+
+ /**
+ * Specify that a certain number of rows should be ignored from the CSV
+ * file. This is useful for skipping processing information
+ *
+ * By default, this is set to 1, as CSV files are expected to
+ * hold a header row.
+ *
+ * @param number The number of rows to ignore.
+ */
+ @Support
+ LoaderJSONOptionsStep ignoreRows(int number);
+
+
+ /**
+ * Specify the input string representation of NULL.
+ *
+ * By default, this is set to null, which means that all empty
+ * strings are loaded into the database as such. In some databases (e.g.
+ * {@link org.jooq.SQLDialect#ORACLE}), this is effectively the same as loading
+ * NULL.
+ *
+ * In order to treat empty strings as null, you can set the
+ * nullString to "". If the null string is
+ * overridden with something like {null}, for instance, then
+ * empty strings will also be loaded as such by jOOQ.
+ */
+ @Support
+ LoaderJSONOptionsStep nullString(String nullString);
+}
diff --git a/jOOQ/src/main/java/org/jooq/LoaderJSONStep.java b/jOOQ/src/main/java/org/jooq/LoaderJSONStep.java
new file mode 100644
index 0000000000..5c2b5593c7
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/LoaderJSONStep.java
@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2009-2013, Data Geekery GmbH (http://www.datageekery.com)
+ * All rights reserved.
+ *
+ * This work is dual-licensed
+ * - under the Apache Software License 2.0 (the "ASL")
+ * - under the jOOQ License and Maintenance Agreement (the "jOOQ License")
+ * =============================================================================
+ * You may choose which license applies to you:
+ *
+ * - If you're using this work with Open Source databases, you may choose
+ * either ASL or jOOQ License.
+ * - If you're using this work with at least one commercial database, you must
+ * choose jOOQ License
+ *
+ * For more information, please visit http://www.jooq.org/licenses
+ *
+ * Apache Software License 2.0:
+ * -----------------------------------------------------------------------------
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * jOOQ License and Maintenance Agreement:
+ * -----------------------------------------------------------------------------
+ * Data Geekery grants the Customer the non-exclusive, timely limited and
+ * non-transferable license to install and use the Software under the terms of
+ * the jOOQ License and Maintenance Agreement.
+ *
+ * This library is distributed with a LIMITED WARRANTY. See the jOOQ License
+ * and Maintenance Agreement for more details: http://www.jooq.org/licensing
+ */
+package org.jooq;
+
+import java.util.Collection;
+
+/**
+ * The Loader API is used for configuring data loads.
+ *
+ * The step in constructing the {@link org.jooq.Loader} object where you can set the
+ * mandatory JSON loader options.
+ *
+ * @author Lukas Eder
+ */
+public interface LoaderJSONStep> {
+
+ /**
+ * Specify the the fields to be loaded into the table in the correct order.
+ * The JSON column at index i is inserted into the table field
+ * at index i. If fields[i] == null, then the JSON
+ * column is skipped.
+ */
+ @Support
+ LoaderJSONOptionsStep fields(Field... fields);
+
+ /**
+ * Specify the the fields to be loaded into the table in the correct order.
+ * The JSON column at index i is inserted into the table field
+ * at index i. If
+ * new ArrayList(fields).get(i) == null, then the JSON column is
+ * skipped.
+ */
+ @Support
+ LoaderJSONOptionsStep fields(Collection> fields);
+
+}
diff --git a/jOOQ/src/main/java/org/jooq/LoaderSourceStep.java b/jOOQ/src/main/java/org/jooq/LoaderSourceStep.java
index 9f5fc35ca2..0c05bb571b 100644
--- a/jOOQ/src/main/java/org/jooq/LoaderSourceStep.java
+++ b/jOOQ/src/main/java/org/jooq/LoaderSourceStep.java
@@ -40,13 +40,13 @@
*/
package org.jooq;
+import org.xml.sax.InputSource;
+
import java.io.File;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.Reader;
-import org.xml.sax.InputSource;
-
/**
* The Loader API is used for configuring data loads.
*
@@ -110,4 +110,29 @@ public interface LoaderSourceStep> {
*/
@Support
LoaderXMLStep loadXML(InputSource source);
+
+ /**
+ * Load JSON data
+ */
+ @Support
+ LoaderJSONStep loadJSON(File file) throws FileNotFoundException;
+
+ /**
+ * Load JSON data
+ */
+ @Support
+ LoaderJSONStep loadJSON(String data);
+
+ /**
+ * Load JSON data
+ */
+ @Support
+ LoaderJSONStep loadJSON(InputStream stream);
+
+ /**
+ * Load JSON data
+ */
+ @Support
+ LoaderJSONStep loadJSON(Reader reader);
+
}
diff --git a/jOOQ/src/main/java/org/jooq/impl/LoaderImpl.java b/jOOQ/src/main/java/org/jooq/impl/LoaderImpl.java
index e9d1323b62..e858d7c368 100644
--- a/jOOQ/src/main/java/org/jooq/impl/LoaderImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/LoaderImpl.java
@@ -35,41 +35,21 @@
*/
package org.jooq.impl;
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.io.StringReader;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import org.jooq.Condition;
-import org.jooq.Configuration;
-import org.jooq.DSLContext;
-import org.jooq.Field;
-import org.jooq.InsertQuery;
-import org.jooq.Loader;
-import org.jooq.LoaderCSVOptionsStep;
-import org.jooq.LoaderCSVStep;
-import org.jooq.LoaderError;
-import org.jooq.LoaderOptionsStep;
-import org.jooq.LoaderXMLStep;
-import org.jooq.SelectQuery;
-import org.jooq.Table;
-import org.jooq.TableRecord;
+import org.jooq.*;
import org.jooq.exception.DataAccessException;
import org.jooq.tools.StringUtils;
import org.jooq.tools.csv.CSVParser;
import org.jooq.tools.csv.CSVReader;
-
+import org.jooq.tools.json.JSONReader;
import org.xml.sax.InputSource;
+import java.io.*;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
/**
* @author Lukas Eder
*/
@@ -80,6 +60,8 @@ class LoaderImpl> implements
LoaderXMLStep,
LoaderCSVStep,
LoaderCSVOptionsStep,
+ LoaderJSONStep,
+ LoaderJSONOptionsStep,
Loader {
// Configuration constants
@@ -97,6 +79,7 @@ class LoaderImpl> implements
private static final int CONTENT_CSV = 0;
private static final int CONTENT_XML = 1;
+ private static final int CONTENT_JSON = 2;
// Configuration data
// ------------------
@@ -309,6 +292,36 @@ class LoaderImpl> implements
return this;
}
+ @Override
+ public LoaderJSONStep loadJSON(File file) throws FileNotFoundException {
+ content = CONTENT_JSON;
+ data = new BufferedReader(new FileReader(file));
+ return this;
+ }
+
+ @Override
+ public LoaderJSONStep loadJSON(String json) {
+ content = CONTENT_JSON;
+ data = new BufferedReader(new StringReader(json));
+ return this;
+
+ }
+
+ @Override
+ public LoaderJSONStep loadJSON(InputStream stream) {
+ content = CONTENT_JSON;
+ data = new BufferedReader(new InputStreamReader(stream));
+ return this;
+ }
+
+ @Override
+ public LoaderJSONStep loadJSON(Reader reader) {
+ content = CONTENT_JSON;
+ data = new BufferedReader(reader);
+ return this;
+ }
+
+
// -------------------------------------------------------------------------
// XML configuration
// -------------------------------------------------------------------------
@@ -327,6 +340,9 @@ class LoaderImpl> implements
else if (content == CONTENT_XML) {
throw new UnsupportedOperationException();
}
+ else if (content == CONTENT_JSON) {
+ executeJSON();
+ }
else {
throw new IllegalStateException();
}
@@ -334,6 +350,126 @@ class LoaderImpl> implements
return this;
}
+ private void executeJSON() throws IOException {
+
+ JSONReader reader = new JSONReader(data);
+
+ try {
+ String[] row = null;
+
+ // TODO: When running in COMMIT_AFTER > 1 or COMMIT_ALL mode, then
+ // it might be better to bulk load / merge n records
+ Iterator rows = reader.readAll().iterator();
+ rowloop: while (rows.hasNext()) {
+ row = rows.next();
+ // [#1627] Handle NULL values
+ for (int i = 0; i < row.length; i++) {
+ if (StringUtils.equals(nullString, row[i])) {
+ row[i] = null;
+ }
+ }
+
+ processed++;
+ InsertQuery insert = create.insertQuery(table);
+
+ for (int i = 0; i < row.length; i++) {
+ if (i < fields.length && fields[i] != null) {
+ addValue0(insert, fields[i], row[i]);
+ }
+ }
+
+ // TODO: This is only supported by some dialects. Let other
+ // dialects execute a SELECT and then either an INSERT or UPDATE
+ if (onDuplicate == ON_DUPLICATE_KEY_UPDATE) {
+ insert.onDuplicateKeyUpdate(true);
+
+ for (int i = 0; i < row.length; i++) {
+ if (i < fields.length && fields[i] != null && !primaryKey[i]) {
+ addValueForUpdate0(insert, fields[i], row[i]);
+ }
+ }
+ }
+
+ // TODO: This can be implemented faster using a MERGE statement
+ // in some dialects
+ else if (onDuplicate == ON_DUPLICATE_KEY_IGNORE) {
+ SelectQuery select = create.selectQuery(table);
+
+ for (int i = 0; i < row.length; i++) {
+ if (i < fields.length && primaryKey[i]) {
+ select.addConditions(getCondition(fields[i], row[i]));
+ }
+ }
+
+ try {
+ if (select.execute() > 0) {
+ ignored++;
+ continue rowloop;
+ }
+ } catch (DataAccessException e) {
+ errors.add(new LoaderErrorImpl(e, row, processed - 1, select));
+ }
+ }
+
+ // Don't do anything. Let the execution fail
+ else if (onDuplicate == ON_DUPLICATE_KEY_ERROR) {
+ }
+
+ try {
+ insert.execute();
+ stored++;
+
+ if (commit == COMMIT_AFTER) {
+ if (processed % commitAfter == 0) {
+ configuration.connectionProvider().acquire().commit();
+ }
+ }
+ } catch (DataAccessException e) {
+ errors.add(new LoaderErrorImpl(e, row, processed - 1, insert));
+ ignored++;
+
+ if (onError == ON_ERROR_ABORT) {
+ break rowloop;
+ }
+ }
+ }
+
+ // Rollback on errors in COMMIT_ALL mode
+ try {
+ if (commit == COMMIT_ALL) {
+ if (!errors.isEmpty()) {
+ stored = 0;
+ configuration.connectionProvider().acquire().rollback();
+ }
+ else {
+ configuration.connectionProvider().acquire().commit();
+ }
+ }
+
+ // Commit remaining elements in COMMIT_AFTER mode
+ else if (commit == COMMIT_AFTER) {
+ if (processed % commitAfter != 0) {
+ configuration.connectionProvider().acquire().commit();
+ }
+ }
+ }
+ catch (DataAccessException e) {
+ errors.add(new LoaderErrorImpl(e, null, processed - 1, null));
+ }
+ }
+
+ // SQLExceptions originating from rollbacks or commits are always fatal
+ // They are propagated, and not swallowed
+ catch (SQLException e) {
+ throw Utils.translate(null, e);
+ }
+ finally {
+ reader.close();
+ }
+
+
+ }
+
private final void executeCSV() throws IOException {
CSVReader reader = new CSVReader(data, separator, quote, ignoreRows);
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/ContainerFactory.java b/jOOQ/src/main/java/org/jooq/tools/json/ContainerFactory.java
new file mode 100644
index 0000000000..a40ca9b5c2
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/tools/json/ContainerFactory.java
@@ -0,0 +1,23 @@
+package org.jooq.tools.json;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Container factory for creating containers for JSON object and JSON array.
+ *
+ * @see org.json.simple.parser.JSONParser#parse(java.io.Reader, ContainerFactory)
+ *
+ * @author FangYidong
+ */
+public interface ContainerFactory {
+ /**
+ * @return A Map instance to store JSON object, or null if you want to use org.json.simple.JSONObject.
+ */
+ Map createObjectContainer();
+
+ /**
+ * @return A List instance to store JSON array, or null if you want to use org.json.simple.JSONArray.
+ */
+ List creatArrayContainer();
+}
\ No newline at end of file
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/ContentHandler.java b/jOOQ/src/main/java/org/jooq/tools/json/ContentHandler.java
new file mode 100644
index 0000000000..1c123cb628
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/tools/json/ContentHandler.java
@@ -0,0 +1,110 @@
+package org.jooq.tools.json;
+
+import java.io.IOException;
+
+/**
+ * A simplified and stoppable SAX-like content handler for stream processing of JSON text.
+ *
+ * @see org.xml.sax.ContentHandler
+ * @see org.json.simple.parser.JSONParser#parse(java.io.Reader, ContentHandler, boolean)
+ *
+ * @author FangYidong
+ */
+public interface ContentHandler {
+ /**
+ * Receive notification of the beginning of JSON processing.
+ * The parser will invoke this method only once.
+ *
+ * @throws ParseException
+ * - JSONParser will stop and throw the same exception to the caller when receiving this exception.
+ */
+ void startJSON() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the end of JSON processing.
+ *
+ * @throws ParseException
+ */
+ void endJSON() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the beginning of a JSON object.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ * - JSONParser will stop and throw the same exception to the caller when receiving this exception.
+ * @see #endJSON
+ */
+ boolean startObject() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the end of a JSON object.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #startObject
+ */
+ boolean endObject() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the beginning of a JSON object entry.
+ *
+ * @param key - Key of a JSON object entry.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #endObjectEntry
+ */
+ boolean startObjectEntry(String key) throws ParseException, IOException;
+
+ /**
+ * Receive notification of the end of the value of previous object entry.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #startObjectEntry
+ */
+ boolean endObjectEntry() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the beginning of a JSON array.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #endArray
+ */
+ boolean startArray() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the end of a JSON array.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #startArray
+ */
+ boolean endArray() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the JSON primitive values:
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean
+ * null
+ *
+ * @param value - Instance of the following:
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean
+ * null
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ */
+ boolean primitive(Object value) throws ParseException, IOException;
+
+}
\ No newline at end of file
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/JSONArray.java b/jOOQ/src/main/java/org/jooq/tools/json/JSONArray.java
index d677f2979c..e617abb04c 100644
--- a/jOOQ/src/main/java/org/jooq/tools/json/JSONArray.java
+++ b/jOOQ/src/main/java/org/jooq/tools/json/JSONArray.java
@@ -22,6 +22,8 @@ package org.jooq.tools.json;
import java.io.IOException;
import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Collection;
import java.util.Iterator;
import java.util.List;
@@ -30,7 +32,25 @@ import java.util.List;
*
* @author FangYidong
*/
-public class JSONArray {
+public class JSONArray extends ArrayList {
+
+
+ /**
+ * Constructs an empty JSONArray.
+ */
+ public JSONArray(){
+ super();
+ }
+
+ /**
+ * Constructs a JSONArray containing the elements of the specified
+ * collection, in the order they are returned by the collection's iterator.
+ *
+ * @param c the collection whose elements are to be placed into this JSONArray
+ */
+ public JSONArray(Collection c){
+ super(c);
+ }
/**
* Encode a list into JSON text and write it to out. If this list is also a
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/JSONObject.java b/jOOQ/src/main/java/org/jooq/tools/json/JSONObject.java
index 6cabb7bcd9..59de86ab47 100644
--- a/jOOQ/src/main/java/org/jooq/tools/json/JSONObject.java
+++ b/jOOQ/src/main/java/org/jooq/tools/json/JSONObject.java
@@ -22,6 +22,7 @@ package org.jooq.tools.json;
import java.io.IOException;
import java.io.Writer;
+import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
@@ -31,7 +32,17 @@ import java.util.Map;
*
* @author FangYidong
*/
-public class JSONObject {
+public class JSONObject extends HashMap{
+
+
+ public JSONObject() {
+ super();
+ }
+
+
+ public JSONObject(Map map) {
+ super(map);
+ }
/**
* Encode a map into JSON text and write it to out. If this map is also a
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/JSONParser.java b/jOOQ/src/main/java/org/jooq/tools/json/JSONParser.java
new file mode 100644
index 0000000000..5e2979f060
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/tools/json/JSONParser.java
@@ -0,0 +1,526 @@
+package org.jooq.tools.json;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * Parser for JSON text. Please note that JSONParser is NOT thread-safe.
+ *
+ * @author FangYidong
+ */
+public class JSONParser {
+ public static final int S_INIT=0;
+ public static final int S_IN_FINISHED_VALUE=1;//string,number,boolean,null,object,array
+ public static final int S_IN_OBJECT=2;
+ public static final int S_IN_ARRAY=3;
+ public static final int S_PASSED_PAIR_KEY=4;
+ public static final int S_IN_PAIR_VALUE=5;
+ public static final int S_END=6;
+ public static final int S_IN_ERROR=-1;
+
+ private LinkedList handlerStatusStack;
+ private Yylex lexer = new Yylex((Reader)null);
+ private Yytoken token = null;
+ private int status = S_INIT;
+
+ private int peekStatus(LinkedList statusStack){
+ if(statusStack.size()==0)
+ return -1;
+ Integer status=(Integer)statusStack.getFirst();
+ return status.intValue();
+ }
+
+ /**
+ * Reset the parser to the initial state without resetting the underlying reader.
+ *
+ */
+ public void reset(){
+ token = null;
+ status = S_INIT;
+ handlerStatusStack = null;
+ }
+
+ /**
+ * Reset the parser to the initial state with a new character reader.
+ *
+ * @param in - The new character reader.
+ * @throws IOException
+ * @throws ParseException
+ */
+ public void reset(Reader in){
+ lexer.yyreset(in);
+ reset();
+ }
+
+ /**
+ * @return The position of the beginning of the current token.
+ */
+ public int getPosition(){
+ return lexer.getPosition();
+ }
+
+ public Object parse(String s) throws ParseException{
+ return parse(s, (ContainerFactory)null);
+ }
+
+ public Object parse(String s, ContainerFactory containerFactory) throws ParseException{
+ StringReader in=new StringReader(s);
+ try{
+ return parse(in, containerFactory);
+ }
+ catch(IOException ie){
+ /*
+ * Actually it will never happen.
+ */
+ throw new ParseException(-1, ParseException.ERROR_UNEXPECTED_EXCEPTION, ie);
+ }
+ }
+
+ public Object parse(Reader in) throws IOException, ParseException{
+ return parse(in, (ContainerFactory)null);
+ }
+
+ /**
+ * Parse JSON text into java object from the input source.
+ *
+ * @param in
+ * @param containerFactory - Use this factory to createyour own JSON object and JSON array containers.
+ * @return Instance of the following:
+ * org.json.simple.JSONObject,
+ * org.json.simple.JSONArray,
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean,
+ * null
+ *
+ * @throws IOException
+ * @throws ParseException
+ */
+ public Object parse(Reader in, ContainerFactory containerFactory) throws IOException, ParseException{
+ reset(in);
+ LinkedList statusStack = new LinkedList();
+ LinkedList valueStack = new LinkedList();
+
+ try{
+ do{
+ nextToken();
+ switch(status){
+ case S_INIT:
+ switch(token.type){
+ case Yytoken.TYPE_VALUE:
+ status=S_IN_FINISHED_VALUE;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(token.value);
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(createObjectContainer(containerFactory));
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(createArrayContainer(containerFactory));
+ break;
+ default:
+ status=S_IN_ERROR;
+ }//inner switch
+ break;
+
+ case S_IN_FINISHED_VALUE:
+ if(token.type==Yytoken.TYPE_EOF)
+ return valueStack.removeFirst();
+ else
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+
+ case S_IN_OBJECT:
+ switch(token.type){
+ case Yytoken.TYPE_COMMA:
+ break;
+ case Yytoken.TYPE_VALUE:
+ if(token.value instanceof String){
+ String key=(String)token.value;
+ valueStack.addFirst(key);
+ status=S_PASSED_PAIR_KEY;
+ statusStack.addFirst(new Integer(status));
+ }
+ else{
+ status=S_IN_ERROR;
+ }
+ break;
+ case Yytoken.TYPE_RIGHT_BRACE:
+ if(valueStack.size()>1){
+ statusStack.removeFirst();
+ valueStack.removeFirst();
+ status=peekStatus(statusStack);
+ }
+ else{
+ status=S_IN_FINISHED_VALUE;
+ }
+ break;
+ default:
+ status=S_IN_ERROR;
+ break;
+ }//inner switch
+ break;
+
+ case S_PASSED_PAIR_KEY:
+ switch(token.type){
+ case Yytoken.TYPE_COLON:
+ break;
+ case Yytoken.TYPE_VALUE:
+ statusStack.removeFirst();
+ String key=(String)valueStack.removeFirst();
+ Map parent=(Map)valueStack.getFirst();
+ parent.put(key,token.value);
+ status=peekStatus(statusStack);
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ statusStack.removeFirst();
+ key=(String)valueStack.removeFirst();
+ parent=(Map)valueStack.getFirst();
+ List newArray=createArrayContainer(containerFactory);
+ parent.put(key,newArray);
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(newArray);
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ statusStack.removeFirst();
+ key=(String)valueStack.removeFirst();
+ parent=(Map)valueStack.getFirst();
+ Map newObject=createObjectContainer(containerFactory);
+ parent.put(key,newObject);
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(newObject);
+ break;
+ default:
+ status=S_IN_ERROR;
+ }
+ break;
+
+ case S_IN_ARRAY:
+ switch(token.type){
+ case Yytoken.TYPE_COMMA:
+ break;
+ case Yytoken.TYPE_VALUE:
+ List val=(List)valueStack.getFirst();
+ val.add(token.value);
+ break;
+ case Yytoken.TYPE_RIGHT_SQUARE:
+ if(valueStack.size()>1){
+ statusStack.removeFirst();
+ valueStack.removeFirst();
+ status=peekStatus(statusStack);
+ }
+ else{
+ status=S_IN_FINISHED_VALUE;
+ }
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ val=(List)valueStack.getFirst();
+ Map newObject=createObjectContainer(containerFactory);
+ val.add(newObject);
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(newObject);
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ val=(List)valueStack.getFirst();
+ List newArray=createArrayContainer(containerFactory);
+ val.add(newArray);
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(newArray);
+ break;
+ default:
+ status=S_IN_ERROR;
+ }//inner switch
+ break;
+ case S_IN_ERROR:
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }//switch
+ if(status==S_IN_ERROR){
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+ }while(token.type!=Yytoken.TYPE_EOF);
+ }
+ catch(IOException ie){
+ throw ie;
+ }
+
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+
+ private void nextToken() throws ParseException, IOException{
+ token = lexer.yylex();
+ if(token == null)
+ token = new Yytoken(Yytoken.TYPE_EOF, null);
+ }
+
+ private Map createObjectContainer(ContainerFactory containerFactory){
+ if(containerFactory == null)
+ return new JSONObject();
+ Map m = containerFactory.createObjectContainer();
+
+ if(m == null)
+ return new JSONObject();
+ return m;
+ }
+
+ private List createArrayContainer(ContainerFactory containerFactory){
+ if(containerFactory == null)
+ return new JSONArray();
+ List l = containerFactory.creatArrayContainer();
+
+ if(l == null)
+ return new JSONArray();
+ return l;
+ }
+
+ public void parse(String s, ContentHandler contentHandler) throws ParseException{
+ parse(s, contentHandler, false);
+ }
+
+ public void parse(String s, ContentHandler contentHandler, boolean isResume) throws ParseException{
+ StringReader in=new StringReader(s);
+ try{
+ parse(in, contentHandler, isResume);
+ }
+ catch(IOException ie){
+ /*
+ * Actually it will never happen.
+ */
+ throw new ParseException(-1, ParseException.ERROR_UNEXPECTED_EXCEPTION, ie);
+ }
+ }
+
+ public void parse(Reader in, ContentHandler contentHandler) throws IOException, ParseException{
+ parse(in, contentHandler, false);
+ }
+
+ /**
+ * Stream processing of JSON text.
+ *
+ * @see ContentHandler
+ *
+ * @param in
+ * @param contentHandler
+ * @param isResume - Indicates if it continues previous parsing operation.
+ * If set to true, resume parsing the old stream, and parameter 'in' will be ignored.
+ * If this method is called for the first time in this instance, isResume will be ignored.
+ *
+ * @throws IOException
+ * @throws ParseException
+ */
+ public void parse(Reader in, ContentHandler contentHandler, boolean isResume) throws IOException, ParseException{
+ if(!isResume){
+ reset(in);
+ handlerStatusStack = new LinkedList();
+ }
+ else{
+ if(handlerStatusStack == null){
+ isResume = false;
+ reset(in);
+ handlerStatusStack = new LinkedList();
+ }
+ }
+
+ LinkedList statusStack = handlerStatusStack;
+
+ try{
+ do{
+ switch(status){
+ case S_INIT:
+ contentHandler.startJSON();
+ nextToken();
+ switch(token.type){
+ case Yytoken.TYPE_VALUE:
+ status=S_IN_FINISHED_VALUE;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.primitive(token.value))
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startObject())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startArray())
+ return;
+ break;
+ default:
+ status=S_IN_ERROR;
+ }//inner switch
+ break;
+
+ case S_IN_FINISHED_VALUE:
+ nextToken();
+ if(token.type==Yytoken.TYPE_EOF){
+ contentHandler.endJSON();
+ status = S_END;
+ return;
+ }
+ else{
+ status = S_IN_ERROR;
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+
+ case S_IN_OBJECT:
+ nextToken();
+ switch(token.type){
+ case Yytoken.TYPE_COMMA:
+ break;
+ case Yytoken.TYPE_VALUE:
+ if(token.value instanceof String){
+ String key=(String)token.value;
+ status=S_PASSED_PAIR_KEY;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startObjectEntry(key))
+ return;
+ }
+ else{
+ status=S_IN_ERROR;
+ }
+ break;
+ case Yytoken.TYPE_RIGHT_BRACE:
+ if(statusStack.size()>1){
+ statusStack.removeFirst();
+ status=peekStatus(statusStack);
+ }
+ else{
+ status=S_IN_FINISHED_VALUE;
+ }
+ if(!contentHandler.endObject())
+ return;
+ break;
+ default:
+ status=S_IN_ERROR;
+ break;
+ }//inner switch
+ break;
+
+ case S_PASSED_PAIR_KEY:
+ nextToken();
+ switch(token.type){
+ case Yytoken.TYPE_COLON:
+ break;
+ case Yytoken.TYPE_VALUE:
+ statusStack.removeFirst();
+ status=peekStatus(statusStack);
+ if(!contentHandler.primitive(token.value))
+ return;
+ if(!contentHandler.endObjectEntry())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ statusStack.removeFirst();
+ statusStack.addFirst(new Integer(S_IN_PAIR_VALUE));
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startArray())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ statusStack.removeFirst();
+ statusStack.addFirst(new Integer(S_IN_PAIR_VALUE));
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startObject())
+ return;
+ break;
+ default:
+ status=S_IN_ERROR;
+ }
+ break;
+
+ case S_IN_PAIR_VALUE:
+ /*
+ * S_IN_PAIR_VALUE is just a marker to indicate the end of an object entry, it doesn't proccess any token,
+ * therefore delay consuming token until next round.
+ */
+ statusStack.removeFirst();
+ status = peekStatus(statusStack);
+ if(!contentHandler.endObjectEntry())
+ return;
+ break;
+
+ case S_IN_ARRAY:
+ nextToken();
+ switch(token.type){
+ case Yytoken.TYPE_COMMA:
+ break;
+ case Yytoken.TYPE_VALUE:
+ if(!contentHandler.primitive(token.value))
+ return;
+ break;
+ case Yytoken.TYPE_RIGHT_SQUARE:
+ if(statusStack.size()>1){
+ statusStack.removeFirst();
+ status=peekStatus(statusStack);
+ }
+ else{
+ status=S_IN_FINISHED_VALUE;
+ }
+ if(!contentHandler.endArray())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startObject())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startArray())
+ return;
+ break;
+ default:
+ status=S_IN_ERROR;
+ }//inner switch
+ break;
+
+ case S_END:
+ return;
+
+ case S_IN_ERROR:
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }//switch
+ if(status==S_IN_ERROR){
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+ }while(token.type!=Yytoken.TYPE_EOF);
+ }
+ catch(IOException ie){
+ status = S_IN_ERROR;
+ throw ie;
+ }
+ catch(ParseException pe){
+ status = S_IN_ERROR;
+ throw pe;
+ }
+ catch(RuntimeException re){
+ status = S_IN_ERROR;
+ throw re;
+ }
+ catch(Error e){
+ status = S_IN_ERROR;
+ throw e;
+ }
+
+ status = S_IN_ERROR;
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+}
\ No newline at end of file
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/JSONReader.java b/jOOQ/src/main/java/org/jooq/tools/json/JSONReader.java
new file mode 100644
index 0000000000..affecc59c2
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/tools/json/JSONReader.java
@@ -0,0 +1,54 @@
+package org.jooq.tools.json;
+
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A very simple JSON reader based on Simple JSON.
+ */
+public class JSONReader implements Closeable {
+
+
+ private final BufferedReader br;
+ private final JSONParser parser;
+
+ public JSONReader(BufferedReader reader) {
+ this.br = reader;
+ this.parser = new JSONParser();
+ }
+
+ @SuppressWarnings("unchecked")
+ public List readAll() throws IOException {
+ List all;
+ try {
+ Object parse = parser.parse(br);
+ JSONObject obj2 = (JSONObject) parse;
+ JSONArray records = (JSONArray) obj2.get("records");
+ all = new ArrayList(records.size());
+ for (Object record : records) {
+ JSONArray values = (JSONArray) record;
+ List v = new ArrayList(values.size());
+ for (Object value : values) {
+ v.add(String.valueOf(value));
+ }
+ all.add(v.toArray(new String[v.size()]));
+ }
+ } catch (ParseException e1) {
+ throw new RuntimeException(e1);
+ } catch (IOException e1) {
+ throw e1;
+ }
+ return all;
+ }
+
+
+ @Override
+ public void close() throws IOException {
+ br.close();
+
+ }
+
+}
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/JSONValue.java b/jOOQ/src/main/java/org/jooq/tools/json/JSONValue.java
index e2c90fde69..3208631af6 100644
--- a/jOOQ/src/main/java/org/jooq/tools/json/JSONValue.java
+++ b/jOOQ/src/main/java/org/jooq/tools/json/JSONValue.java
@@ -21,6 +21,7 @@
package org.jooq.tools.json;
import java.io.IOException;
+import java.io.Reader;
import java.io.Writer;
import java.util.List;
import java.util.Map;
@@ -209,4 +210,32 @@ public class JSONValue {
}
}// for
}
+
+ /**
+ * Parse JSON text into java object from the input source.
+ *
+ * @see org.json.simple.parser.JSONParser
+ *
+ * @param in
+ * @return Instance of the following:
+ * org.json.simple.JSONObject,
+ * org.json.simple.JSONArray,
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean,
+ * null
+ *
+ * @throws IOException
+ * @throws ParseException
+ */
+ public static Object parseWithException(Reader in) throws IOException, ParseException{
+ JSONParser parser=new JSONParser();
+ return parser.parse(in);
+ }
+
+ public static Object parseWithException(String s) throws ParseException{
+ JSONParser parser=new JSONParser();
+ return parser.parse(s);
+ }
+
}
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/ParseException.java b/jOOQ/src/main/java/org/jooq/tools/json/ParseException.java
new file mode 100644
index 0000000000..380c4b19b7
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/tools/json/ParseException.java
@@ -0,0 +1,90 @@
+package org.jooq.tools.json;
+
+/**
+ * ParseException explains why and where the error occurs in source JSON text.
+ *
+ * @author FangYidong
+ *
+ */
+public class ParseException extends Exception {
+ private static final long serialVersionUID = -7880698968187728547L;
+
+ public static final int ERROR_UNEXPECTED_CHAR = 0;
+ public static final int ERROR_UNEXPECTED_TOKEN = 1;
+ public static final int ERROR_UNEXPECTED_EXCEPTION = 2;
+
+ private int errorType;
+ private Object unexpectedObject;
+ private int position;
+
+ public ParseException(int errorType){
+ this(-1, errorType, null);
+ }
+
+ public ParseException(int errorType, Object unexpectedObject){
+ this(-1, errorType, unexpectedObject);
+ }
+
+ public ParseException(int position, int errorType, Object unexpectedObject){
+ this.position = position;
+ this.errorType = errorType;
+ this.unexpectedObject = unexpectedObject;
+ }
+
+ public int getErrorType() {
+ return errorType;
+ }
+
+ public void setErrorType(int errorType) {
+ this.errorType = errorType;
+ }
+
+ /**
+ * @see org.json.simple.parser.JSONParser#getPosition()
+ *
+ * @return The character position (starting with 0) of the input where the error occurs.
+ */
+ public int getPosition() {
+ return position;
+ }
+
+ public void setPosition(int position) {
+ this.position = position;
+ }
+
+ /**
+ * @see org.json.simple.parser.Yytoken
+ *
+ * @return One of the following base on the value of errorType:
+ * ERROR_UNEXPECTED_CHAR java.lang.Character
+ * ERROR_UNEXPECTED_TOKEN org.json.simple.parser.Yytoken
+ * ERROR_UNEXPECTED_EXCEPTION java.lang.Exception
+ */
+ public Object getUnexpectedObject() {
+ return unexpectedObject;
+ }
+
+ public void setUnexpectedObject(Object unexpectedObject) {
+ this.unexpectedObject = unexpectedObject;
+ }
+
+ public String getMessage() {
+ StringBuffer sb = new StringBuffer();
+
+ switch(errorType){
+ case ERROR_UNEXPECTED_CHAR:
+ sb.append("Unexpected character (").append(unexpectedObject).append(") at position ").append(position).append(".");
+ break;
+ case ERROR_UNEXPECTED_TOKEN:
+ sb.append("Unexpected token ").append(unexpectedObject).append(" at position ").append(position).append(".");
+ break;
+ case ERROR_UNEXPECTED_EXCEPTION:
+ sb.append("Unexpected exception at position ").append(position).append(": ").append(unexpectedObject);
+ break;
+ default:
+ sb.append("Unkown error at position ").append(position).append(".");
+ break;
+ }
+ return sb.toString();
+ }
+}
\ No newline at end of file
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/Yylex.java b/jOOQ/src/main/java/org/jooq/tools/json/Yylex.java
new file mode 100644
index 0000000000..5d3d2ed735
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/tools/json/Yylex.java
@@ -0,0 +1,686 @@
+package org.jooq.tools.json;
+
+class Yylex {
+
+ /** This character denotes the end of file */
+ public static final int YYEOF = -1;
+
+ /** initial size of the lookahead buffer */
+ private static final int ZZ_BUFFERSIZE = 16384;
+
+ /** lexical states */
+ public static final int YYINITIAL = 0;
+ public static final int STRING_BEGIN = 2;
+
+ /**
+ * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
+ * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
+ * at the beginning of a line
+ * l is of the form l = 2*k, k a non negative integer
+ */
+ private static final int ZZ_LEXSTATE[] = {
+ 0, 0, 1, 1
+ };
+
+ /**
+ * Translates characters to character classes
+ */
+ private static final String ZZ_CMAP_PACKED =
+ "\11\0\1\7\1\7\2\0\1\7\22\0\1\7\1\0\1\11\10\0"+
+ "\1\6\1\31\1\2\1\4\1\12\12\3\1\32\6\0\4\1\1\5"+
+ "\1\1\24\0\1\27\1\10\1\30\3\0\1\22\1\13\2\1\1\21"+
+ "\1\14\5\0\1\23\1\0\1\15\3\0\1\16\1\24\1\17\1\20"+
+ "\5\0\1\25\1\0\1\26\uff82\0";
+
+ /**
+ * Translates characters to character classes
+ */
+ private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED);
+
+ /**
+ * Translates DFA states to action switch labels.
+ */
+ private static final int [] ZZ_ACTION = zzUnpackAction();
+
+ private static final String ZZ_ACTION_PACKED_0 =
+ "\2\0\2\1\1\2\1\3\1\4\3\1\1\5\1\6"+
+ "\1\7\1\10\1\11\1\12\1\13\1\14\1\15\5\0"+
+ "\1\14\1\16\1\17\1\20\1\21\1\22\1\23\1\24"+
+ "\1\0\1\25\1\0\1\25\4\0\1\26\1\27\2\0"+
+ "\1\30";
+
+ private static int [] zzUnpackAction() {
+ int [] result = new int[45];
+ int offset = 0;
+ offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
+ return result;
+ }
+
+ private static int zzUnpackAction(String packed, int offset, int [] result) {
+ int i = 0; /* index in packed string */
+ int j = offset; /* index in unpacked array */
+ int l = packed.length();
+ while (i < l) {
+ int count = packed.charAt(i++);
+ int value = packed.charAt(i++);
+ do result[j++] = value; while (--count > 0);
+ }
+ return j;
+ }
+
+
+ /**
+ * Translates a state to a row index in the transition table
+ */
+ private static final int [] ZZ_ROWMAP = zzUnpackRowMap();
+
+ private static final String ZZ_ROWMAP_PACKED_0 =
+ "\0\0\0\33\0\66\0\121\0\154\0\207\0\66\0\242"+
+ "\0\275\0\330\0\66\0\66\0\66\0\66\0\66\0\66"+
+ "\0\363\0\u010e\0\66\0\u0129\0\u0144\0\u015f\0\u017a\0\u0195"+
+ "\0\66\0\66\0\66\0\66\0\66\0\66\0\66\0\66"+
+ "\0\u01b0\0\u01cb\0\u01e6\0\u01e6\0\u0201\0\u021c\0\u0237\0\u0252"+
+ "\0\66\0\66\0\u026d\0\u0288\0\66";
+
+ private static int [] zzUnpackRowMap() {
+ int [] result = new int[45];
+ int offset = 0;
+ offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
+ return result;
+ }
+
+ private static int zzUnpackRowMap(String packed, int offset, int [] result) {
+ int i = 0; /* index in packed string */
+ int j = offset; /* index in unpacked array */
+ int l = packed.length();
+ while (i < l) {
+ int high = packed.charAt(i++) << 16;
+ result[j++] = high | packed.charAt(i++);
+ }
+ return j;
+ }
+
+ /**
+ * The transition table of the DFA
+ */
+ private static final int ZZ_TRANS [] = {
+ 2, 2, 3, 4, 2, 2, 2, 5, 2, 6,
+ 2, 2, 7, 8, 2, 9, 2, 2, 2, 2,
+ 2, 10, 11, 12, 13, 14, 15, 16, 16, 16,
+ 16, 16, 16, 16, 16, 17, 18, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 4, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 4, 19, 20, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 20, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 5, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 21, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 22, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 23, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 16, 16, 16, 16, 16, 16, 16,
+ 16, -1, -1, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ -1, -1, -1, -1, -1, -1, -1, -1, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 33, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 34, 35, -1, -1,
+ 34, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 36, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 37, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 38, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 39, -1, 39, -1, 39, -1, -1,
+ -1, -1, -1, 39, 39, -1, -1, -1, -1, 39,
+ 39, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 33, -1, 20, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 20, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 35,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 38, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 40,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 41, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 42, -1, 42, -1, 42,
+ -1, -1, -1, -1, -1, 42, 42, -1, -1, -1,
+ -1, 42, 42, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 43, -1, 43, -1, 43, -1, -1, -1,
+ -1, -1, 43, 43, -1, -1, -1, -1, 43, 43,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 44,
+ -1, 44, -1, 44, -1, -1, -1, -1, -1, 44,
+ 44, -1, -1, -1, -1, 44, 44, -1, -1, -1,
+ -1, -1, -1, -1, -1,
+ };
+
+ /* error codes */
+ private static final int ZZ_UNKNOWN_ERROR = 0;
+ private static final int ZZ_NO_MATCH = 1;
+ private static final int ZZ_PUSHBACK_2BIG = 2;
+
+ /* error messages for the codes above */
+ private static final String ZZ_ERROR_MSG[] = {
+ "Unkown internal scanner error",
+ "Error: could not match input",
+ "Error: pushback value was too large"
+ };
+
+ /**
+ * ZZ_ATTRIBUTE[aState] contains the attributes of state aState
+ */
+ private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();
+
+ private static final String ZZ_ATTRIBUTE_PACKED_0 =
+ "\2\0\1\11\3\1\1\11\3\1\6\11\2\1\1\11"+
+ "\5\0\10\11\1\0\1\1\1\0\1\1\4\0\2\11"+
+ "\2\0\1\11";
+
+ private static int [] zzUnpackAttribute() {
+ int [] result = new int[45];
+ int offset = 0;
+ offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
+ return result;
+ }
+
+ private static int zzUnpackAttribute(String packed, int offset, int [] result) {
+ int i = 0; /* index in packed string */
+ int j = offset; /* index in unpacked array */
+ int l = packed.length();
+ while (i < l) {
+ int count = packed.charAt(i++);
+ int value = packed.charAt(i++);
+ do result[j++] = value; while (--count > 0);
+ }
+ return j;
+ }
+
+ /** the input device */
+ private java.io.Reader zzReader;
+
+ /** the current state of the DFA */
+ private int zzState;
+
+ /** the current lexical state */
+ private int zzLexicalState = YYINITIAL;
+
+ /** this buffer contains the current text to be matched and is
+ the source of the yytext() string */
+ private char zzBuffer[] = new char[ZZ_BUFFERSIZE];
+
+ /** the textposition at the last accepting state */
+ private int zzMarkedPos;
+
+ /** the current text position in the buffer */
+ private int zzCurrentPos;
+
+ /** startRead marks the beginning of the yytext() string in the buffer */
+ private int zzStartRead;
+
+ /** endRead marks the last character in the buffer, that has been read
+ from input */
+ private int zzEndRead;
+
+ /** number of newlines encountered up to the start of the matched text */
+ private int yyline;
+
+ /** the number of characters up to the start of the matched text */
+ private int yychar;
+
+ /**
+ * the number of characters from the last newline up to the start of the
+ * matched text
+ */
+ private int yycolumn;
+
+ /**
+ * zzAtBOL == true <=> the scanner is currently at the beginning of a line
+ */
+ private boolean zzAtBOL = true;
+
+ /** zzAtEOF == true <=> the scanner is at the EOF */
+ private boolean zzAtEOF;
+
+ /* user code: */
+ private StringBuffer sb=new StringBuffer();
+
+ int getPosition(){
+ return yychar;
+ }
+
+
+
+ /**
+ * Creates a new scanner
+ * There is also a java.io.InputStream version of this constructor.
+ *
+ * @param in the java.io.Reader to read input from.
+ */
+ Yylex(java.io.Reader in) {
+ this.zzReader = in;
+ }
+
+ /**
+ * Creates a new scanner.
+ * There is also java.io.Reader version of this constructor.
+ *
+ * @param in the java.io.Inputstream to read input from.
+ */
+ Yylex(java.io.InputStream in) {
+ this(new java.io.InputStreamReader(in));
+ }
+
+ /**
+ * Unpacks the compressed character translation table.
+ *
+ * @param packed the packed character translation table
+ * @return the unpacked character translation table
+ */
+ private static char [] zzUnpackCMap(String packed) {
+ char [] map = new char[0x10000];
+ int i = 0; /* index in packed string */
+ int j = 0; /* index in unpacked array */
+ while (i < 90) {
+ int count = packed.charAt(i++);
+ char value = packed.charAt(i++);
+ do map[j++] = value; while (--count > 0);
+ }
+ return map;
+ }
+
+
+ /**
+ * Refills the input buffer.
+ *
+ * @return false, iff there was new input.
+ *
+ * @exception java.io.IOException if any I/O-Error occurs
+ */
+ private boolean zzRefill() throws java.io.IOException {
+
+ /* first: make room (if you can) */
+ if (zzStartRead > 0) {
+ System.arraycopy(zzBuffer, zzStartRead,
+ zzBuffer, 0,
+ zzEndRead-zzStartRead);
+
+ /* translate stored positions */
+ zzEndRead-= zzStartRead;
+ zzCurrentPos-= zzStartRead;
+ zzMarkedPos-= zzStartRead;
+ zzStartRead = 0;
+ }
+
+ /* is the buffer big enough? */
+ if (zzCurrentPos >= zzBuffer.length) {
+ /* if not: blow it up */
+ char newBuffer[] = new char[zzCurrentPos*2];
+ System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
+ zzBuffer = newBuffer;
+ }
+
+ /* finally: fill the buffer with new input */
+ int numRead = zzReader.read(zzBuffer, zzEndRead,
+ zzBuffer.length-zzEndRead);
+
+ if (numRead > 0) {
+ zzEndRead+= numRead;
+ return false;
+ }
+ // unlikely but not impossible: read 0 characters, but not at end of stream
+ if (numRead == 0) {
+ int c = zzReader.read();
+ if (c == -1) {
+ return true;
+ } else {
+ zzBuffer[zzEndRead++] = (char) c;
+ return false;
+ }
+ }
+
+ // numRead < 0
+ return true;
+ }
+
+
+ /**
+ * Closes the input stream.
+ */
+ public final void yyclose() throws java.io.IOException {
+ zzAtEOF = true; /* indicate end of file */
+ zzEndRead = zzStartRead; /* invalidate buffer */
+
+ if (zzReader != null)
+ zzReader.close();
+ }
+
+
+ /**
+ * Resets the scanner to read from a new input stream.
+ * Does not close the old reader.
+ *
+ * All internal variables are reset, the old input stream
+ * cannot be reused (internal buffer is discarded and lost).
+ * Lexical state is set to ZZ_INITIAL.
+ *
+ * @param reader the new input stream
+ */
+ public final void yyreset(java.io.Reader reader) {
+ zzReader = reader;
+ zzAtBOL = true;
+ zzAtEOF = false;
+ zzEndRead = zzStartRead = 0;
+ zzCurrentPos = zzMarkedPos = 0;
+ yyline = yychar = yycolumn = 0;
+ zzLexicalState = YYINITIAL;
+ }
+
+
+ /**
+ * Returns the current lexical state.
+ */
+ public final int yystate() {
+ return zzLexicalState;
+ }
+
+
+ /**
+ * Enters a new lexical state
+ *
+ * @param newState the new lexical state
+ */
+ public final void yybegin(int newState) {
+ zzLexicalState = newState;
+ }
+
+
+ /**
+ * Returns the text matched by the current regular expression.
+ */
+ public final String yytext() {
+ return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead );
+ }
+
+
+ /**
+ * Returns the character at position pos from the
+ * matched text.
+ *
+ * It is equivalent to yytext().charAt(pos), but faster
+ *
+ * @param pos the position of the character to fetch.
+ * A value from 0 to yylength()-1.
+ *
+ * @return the character at position pos
+ */
+ public final char yycharat(int pos) {
+ return zzBuffer[zzStartRead+pos];
+ }
+
+
+ /**
+ * Returns the length of the matched text region.
+ */
+ public final int yylength() {
+ return zzMarkedPos-zzStartRead;
+ }
+
+
+ /**
+ * Reports an error that occured while scanning.
+ *
+ * In a wellformed scanner (no or only correct usage of
+ * yypushback(int) and a match-all fallback rule) this method
+ * will only be called with things that "Can't Possibly Happen".
+ * If this method is called, something is seriously wrong
+ * (e.g. a JFlex bug producing a faulty scanner etc.).
+ *
+ * Usual syntax/scanner level error handling should be done
+ * in error fallback rules.
+ *
+ * @param errorCode the code of the errormessage to display
+ */
+ private void zzScanError(int errorCode) {
+ String message;
+ try {
+ message = ZZ_ERROR_MSG[errorCode];
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
+ }
+
+ throw new Error(message);
+ }
+
+
+ /**
+ * Pushes the specified amount of characters back into the input stream.
+ *
+ * They will be read again by then next call of the scanning method
+ *
+ * @param number the number of characters to be read again.
+ * This number must not be greater than yylength()!
+ */
+ public void yypushback(int number) {
+ if ( number > yylength() )
+ zzScanError(ZZ_PUSHBACK_2BIG);
+
+ zzMarkedPos -= number;
+ }
+
+
+ /**
+ * Resumes scanning until the next regular expression is matched,
+ * the end of input is encountered or an I/O-Error occurs.
+ *
+ * @return the next token
+ * @exception java.io.IOException if any I/O-Error occurs
+ */
+ public Yytoken yylex() throws java.io.IOException, ParseException {
+ int zzInput;
+ int zzAction;
+
+ // cached fields:
+ int zzCurrentPosL;
+ int zzMarkedPosL;
+ int zzEndReadL = zzEndRead;
+ char [] zzBufferL = zzBuffer;
+ char [] zzCMapL = ZZ_CMAP;
+
+ int [] zzTransL = ZZ_TRANS;
+ int [] zzRowMapL = ZZ_ROWMAP;
+ int [] zzAttrL = ZZ_ATTRIBUTE;
+
+ while (true) {
+ zzMarkedPosL = zzMarkedPos;
+
+ yychar+= zzMarkedPosL-zzStartRead;
+
+ zzAction = -1;
+
+ zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
+
+ zzState = ZZ_LEXSTATE[zzLexicalState];
+
+
+ zzForAction: {
+ while (true) {
+
+ if (zzCurrentPosL < zzEndReadL)
+ zzInput = zzBufferL[zzCurrentPosL++];
+ else if (zzAtEOF) {
+ zzInput = YYEOF;
+ break zzForAction;
+ }
+ else {
+ // store back cached positions
+ zzCurrentPos = zzCurrentPosL;
+ zzMarkedPos = zzMarkedPosL;
+ boolean eof = zzRefill();
+ // get translated positions and possibly new buffer
+ zzCurrentPosL = zzCurrentPos;
+ zzMarkedPosL = zzMarkedPos;
+ zzBufferL = zzBuffer;
+ zzEndReadL = zzEndRead;
+ if (eof) {
+ zzInput = YYEOF;
+ break zzForAction;
+ }
+ else {
+ zzInput = zzBufferL[zzCurrentPosL++];
+ }
+ }
+ int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
+ if (zzNext == -1) break zzForAction;
+ zzState = zzNext;
+
+ int zzAttributes = zzAttrL[zzState];
+ if ( (zzAttributes & 1) == 1 ) {
+ zzAction = zzState;
+ zzMarkedPosL = zzCurrentPosL;
+ if ( (zzAttributes & 8) == 8 ) break zzForAction;
+ }
+
+ }
+ }
+
+ // store back cached position
+ zzMarkedPos = zzMarkedPosL;
+
+ switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
+ case 11:
+ { sb.append(yytext());
+ }
+ case 25: break;
+ case 4:
+ { sb = null; sb = new StringBuffer(); yybegin(STRING_BEGIN);
+ }
+ case 26: break;
+ case 16:
+ { sb.append('\b');
+ }
+ case 27: break;
+ case 6:
+ { return new Yytoken(Yytoken.TYPE_RIGHT_BRACE,null);
+ }
+ case 28: break;
+ case 23:
+ { Boolean val=Boolean.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
+ }
+ case 29: break;
+ case 22:
+ { return new Yytoken(Yytoken.TYPE_VALUE, null);
+ }
+ case 30: break;
+ case 13:
+ { yybegin(YYINITIAL);return new Yytoken(Yytoken.TYPE_VALUE, sb.toString());
+ }
+ case 31: break;
+ case 12:
+ { sb.append('\\');
+ }
+ case 32: break;
+ case 21:
+ { Double val=Double.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
+ }
+ case 33: break;
+ case 1:
+ { throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_CHAR, new Character(yycharat(0)));
+ }
+ case 34: break;
+ case 8:
+ { return new Yytoken(Yytoken.TYPE_RIGHT_SQUARE,null);
+ }
+ case 35: break;
+ case 19:
+ { sb.append('\r');
+ }
+ case 36: break;
+ case 15:
+ { sb.append('/');
+ }
+ case 37: break;
+ case 10:
+ { return new Yytoken(Yytoken.TYPE_COLON,null);
+ }
+ case 38: break;
+ case 14:
+ { sb.append('"');
+ }
+ case 39: break;
+ case 5:
+ { return new Yytoken(Yytoken.TYPE_LEFT_BRACE,null);
+ }
+ case 40: break;
+ case 17:
+ { sb.append('\f');
+ }
+ case 41: break;
+ case 24:
+ { try{
+ int ch=Integer.parseInt(yytext().substring(2),16);
+ sb.append((char)ch);
+ }
+ catch(Exception e){
+ throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_EXCEPTION, e);
+ }
+ }
+ case 42: break;
+ case 20:
+ { sb.append('\t');
+ }
+ case 43: break;
+ case 7:
+ { return new Yytoken(Yytoken.TYPE_LEFT_SQUARE,null);
+ }
+ case 44: break;
+ case 2:
+ { Long val=Long.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
+ }
+ case 45: break;
+ case 18:
+ { sb.append('\n');
+ }
+ case 46: break;
+ case 9:
+ { return new Yytoken(Yytoken.TYPE_COMMA,null);
+ }
+ case 47: break;
+ case 3:
+ {
+ }
+ case 48: break;
+ default:
+ if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
+ zzAtEOF = true;
+ return null;
+ }
+ else {
+ zzScanError(ZZ_NO_MATCH);
+ }
+ }
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/Yytoken.java b/jOOQ/src/main/java/org/jooq/tools/json/Yytoken.java
new file mode 100644
index 0000000000..8a2650944a
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/tools/json/Yytoken.java
@@ -0,0 +1,51 @@
+package org.jooq.tools.json;
+
+public class Yytoken {
+ public static final int TYPE_VALUE=0;//JSON primitive value: string,number,boolean,null
+ public static final int TYPE_LEFT_BRACE=1;
+ public static final int TYPE_RIGHT_BRACE=2;
+ public static final int TYPE_LEFT_SQUARE=3;
+ public static final int TYPE_RIGHT_SQUARE=4;
+ public static final int TYPE_COMMA=5;
+ public static final int TYPE_COLON=6;
+ public static final int TYPE_EOF=-1;//end of file
+
+ public int type=0;
+ public Object value=null;
+
+ public Yytoken(int type,Object value){
+ this.type=type;
+ this.value=value;
+ }
+
+ public String toString(){
+ StringBuffer sb = new StringBuffer();
+ switch(type){
+ case TYPE_VALUE:
+ sb.append("VALUE(").append(value).append(")");
+ break;
+ case TYPE_LEFT_BRACE:
+ sb.append("LEFT BRACE({)");
+ break;
+ case TYPE_RIGHT_BRACE:
+ sb.append("RIGHT BRACE(})");
+ break;
+ case TYPE_LEFT_SQUARE:
+ sb.append("LEFT SQUARE([)");
+ break;
+ case TYPE_RIGHT_SQUARE:
+ sb.append("RIGHT SQUARE(])");
+ break;
+ case TYPE_COMMA:
+ sb.append("COMMA(,)");
+ break;
+ case TYPE_COLON:
+ sb.append("COLON(:)");
+ break;
+ case TYPE_EOF:
+ sb.append("END OF FILE");
+ break;
+ }
+ return sb.toString();
+ }
+}
\ No newline at end of file