You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@phoenix.apache.org by je...@apache.org on 2014/03/05 23:55:10 UTC

[24/50] [abbrv] PHOENIX-53 Replace CSV loader with Apache Commons CSV loader (JamesViolette)

http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/738619db/phoenix-core/src/main/java/org/apache/commons/csv/Lexer.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/commons/csv/Lexer.java b/phoenix-core/src/main/java/org/apache/commons/csv/Lexer.java
new file mode 100644
index 0000000..95cf13d
--- /dev/null
+++ b/phoenix-core/src/main/java/org/apache/commons/csv/Lexer.java
@@ -0,0 +1,431 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+package org.apache.commons.csv;
+
+import static org.apache.commons.csv.Constants.BACKSPACE;
+import static org.apache.commons.csv.Constants.CR;
+import static org.apache.commons.csv.Constants.END_OF_STREAM;
+import static org.apache.commons.csv.Constants.FF;
+import static org.apache.commons.csv.Constants.LF;
+import static org.apache.commons.csv.Constants.TAB;
+import static org.apache.commons.csv.Constants.UNDEFINED;
+import static org.apache.commons.csv.Token.Type.COMMENT;
+import static org.apache.commons.csv.Token.Type.EOF;
+import static org.apache.commons.csv.Token.Type.EORECORD;
+import static org.apache.commons.csv.Token.Type.INVALID;
+import static org.apache.commons.csv.Token.Type.TOKEN;
+
+import java.io.IOException;
+
+/**
+ *
+ *
+ * @version $Id: Lexer.java 1512650 2013-08-10 11:46:28Z britter $
+ */
+final class Lexer {
+
+    /**
+     * Constant char to use for disabling comments, escapes and encapsulation. The value -2 is used because it
+     * won't be confused with an EOF signal (-1), and because the Unicode value {@code FFFE} would be encoded as two
+     * chars (using surrogates) and thus there should never be a collision with a real text char.
+     */
+    private static final char DISABLED = '\ufffe';
+
+    private final char delimiter;
+    private final char escape;
+    private final char quoteChar;
+    private final char commentStart;
+
+    private final boolean ignoreSurroundingSpaces;
+    private final boolean ignoreEmptyLines;
+
+    /** The input stream */
+    private final ExtendedBufferedReader in;
+
+    /** INTERNAL API. but ctor needs to be called dynamically by PerformanceTest class */
+    Lexer(final CSVFormat format, final ExtendedBufferedReader in) {
+        this.in = in;
+        this.delimiter = format.getDelimiter();
+        this.escape = mapNullToDisabled(format.getEscape());
+        this.quoteChar = mapNullToDisabled(format.getQuoteChar());
+        this.commentStart = mapNullToDisabled(format.getCommentStart());
+        this.ignoreSurroundingSpaces = format.getIgnoreSurroundingSpaces();
+        this.ignoreEmptyLines = format.getIgnoreEmptyLines();
+    }
+
+    /**
+     * Returns the next token.
+     * <p/>
+     * A token corresponds to a term, a record change or an end-of-file indicator.
+     *
+     * @param token
+     *            an existing Token object to reuse. The caller is responsible to initialize the Token.
+     * @return the next token found
+     * @throws java.io.IOException
+     *             on stream access error
+     */
+    Token nextToken(final Token token) throws IOException {
+
+        // get the last read char (required for empty line detection)
+        int lastChar = in.getLastChar();
+
+        // read the next char and set eol
+        int c = in.read();
+        /*
+         * Note: The following call will swallow LF if c == CR. But we don't need to know if the last char was CR or LF
+         * - they are equivalent here.
+         */
+        boolean eol = readEndOfLine(c);
+
+        // empty line detection: eol AND (last char was EOL or beginning)
+        if (ignoreEmptyLines) {
+            while (eol && isStartOfLine(lastChar)) {
+                // go on char ahead ...
+                lastChar = c;
+                c = in.read();
+                eol = readEndOfLine(c);
+                // reached end of file without any content (empty line at the end)
+                if (isEndOfFile(c)) {
+                    token.type = EOF;
+                    // don't set token.isReady here because no content
+                    return token;
+                }
+            }
+        }
+
+        // did we reach eof during the last iteration already ? EOF
+        if (isEndOfFile(lastChar) || (!isDelimiter(lastChar) && isEndOfFile(c))) {
+            token.type = EOF;
+            // don't set token.isReady here because no content
+            return token;
+        }
+
+        if (isStartOfLine(lastChar) && isCommentStart(c)) {
+            final String line = in.readLine();
+            if (line == null) {
+                token.type = EOF;
+                // don't set token.isReady here because no content
+                return token;
+            }
+            final String comment = line.trim();
+            token.content.append(comment);
+            token.type = COMMENT;
+            return token;
+        }
+
+        // important: make sure a new char gets consumed in each iteration
+        while (token.type == INVALID) {
+            // ignore whitespaces at beginning of a token
+            if (ignoreSurroundingSpaces) {
+                while (isWhitespace(c) && !eol) {
+                    c = in.read();
+                    eol = readEndOfLine(c);
+                }
+            }
+
+            // ok, start of token reached: encapsulated, or token
+            if (isDelimiter(c)) {
+                // empty token return TOKEN("")
+                token.type = TOKEN;
+            } else if (eol) {
+                // empty token return EORECORD("")
+                // noop: token.content.append("");
+                token.type = EORECORD;
+            } else if (isQuoteChar(c)) {
+                // consume encapsulated token
+                parseEncapsulatedToken(token);
+            } else if (isEndOfFile(c)) {
+                // end of file return EOF()
+                // noop: token.content.append("");
+                token.type = EOF;
+                token.isReady = true; // there is data at EOF
+            } else {
+                // next token must be a simple token
+                // add removed blanks when not ignoring whitespace chars...
+                parseSimpleToken(token, c);
+            }
+        }
+        return token;
+    }
+
+    /**
+     * Parses a simple token.
+     * <p/>
+     * Simple token are tokens which are not surrounded by encapsulators. A simple token might contain escaped
+     * delimiters (as \, or \;). The token is finished when one of the following conditions become true:
+     * <ul>
+     * <li>end of line has been reached (EORECORD)</li>
+     * <li>end of stream has been reached (EOF)</li>
+     * <li>an unescaped delimiter has been reached (TOKEN)</li>
+     * </ul>
+     *
+     * @param token
+     *            the current token
+     * @param ch
+     *            the current character
+     * @return the filled token
+     * @throws IOException
+     *             on stream access error
+     */
+    private Token parseSimpleToken(final Token token, int ch) throws IOException {
+        // Faster to use while(true)+break than while(token.type == INVALID)
+        while (true) {
+            if (readEndOfLine(ch)) {
+                token.type = EORECORD;
+                break;
+            } else if (isEndOfFile(ch)) {
+                token.type = EOF;
+                token.isReady = true; // There is data at EOF
+                break;
+            } else if (isDelimiter(ch)) {
+                token.type = TOKEN;
+                break;
+            } else if (isEscape(ch)) {
+                final int unescaped = readEscape();
+                if (unescaped == Constants.END_OF_STREAM) { // unexpected char after escape
+                    token.content.append((char) ch).append((char) in.getLastChar());
+                } else {
+                    token.content.append((char) unescaped);
+                }
+                ch = in.read(); // continue
+            } else {
+                token.content.append((char) ch);
+                ch = in.read(); // continue
+            }
+        }
+
+        if (ignoreSurroundingSpaces) {
+            trimTrailingSpaces(token.content);
+        }
+
+        return token;
+    }
+
+    /**
+     * Parses an encapsulated token.
+     * <p/>
+     * Encapsulated tokens are surrounded by the given encapsulating-string. The encapsulator itself might be included
+     * in the token using a doubling syntax (as "", '') or using escaping (as in \", \'). Whitespaces before and after
+     * an encapsulated token are ignored. The token is finished when one of the following conditions become true:
+     * <ul>
+     * <li>an unescaped encapsulator has been reached, and is followed by optional whitespace then:</li>
+     * <ul>
+     * <li>delimiter (TOKEN)</li>
+     * <li>end of line (EORECORD)</li>
+     * </ul>
+     * <li>end of stream has been reached (EOF)</li> </ul>
+     *
+     * @param token
+     *            the current token
+     * @return a valid token object
+     * @throws IOException
+     *             on invalid state: EOF before closing encapsulator or invalid character before delimiter or EOL
+     */
+    private Token parseEncapsulatedToken(final Token token) throws IOException {
+        // save current line number in case needed for IOE
+        final long startLineNumber = getCurrentLineNumber();
+        int c;
+        while (true) {
+            c = in.read();
+
+            if (isEscape(c)) {
+                final int unescaped = readEscape();
+                if (unescaped == Constants.END_OF_STREAM) { // unexpected char after escape
+                    token.content.append((char) c).append((char) in.getLastChar());
+                } else {
+                    token.content.append((char) unescaped);
+                }
+            } else if (isQuoteChar(c)) {
+                if (isQuoteChar(in.lookAhead())) {
+                    // double or escaped encapsulator -> add single encapsulator to token
+                    c = in.read();
+                    token.content.append((char) c);
+                } else {
+                    // token finish mark (encapsulator) reached: ignore whitespace till delimiter
+                    while (true) {
+                        c = in.read();
+                        if (isDelimiter(c)) {
+                            token.type = TOKEN;
+                            return token;
+                        } else if (isEndOfFile(c)) {
+                            token.type = EOF;
+                            token.isReady = true; // There is data at EOF
+                            return token;
+                        } else if (readEndOfLine(c)) {
+                            token.type = EORECORD;
+                            return token;
+                        } else if (!isWhitespace(c)) {
+                            // error invalid char between token and next delimiter
+                            throw new IOException("(line " + getCurrentLineNumber() +
+                                    ") invalid char between encapsulated token and delimiter.");
+                        }
+                    }
+                }
+            } else if (isEndOfFile(c)) {
+                // error condition (end of file before end of token)
+                throw new IOException("(startline " + startLineNumber +
+                        ") EOF reached before encapsulated token finished");
+            } else {
+                // consume character
+                token.content.append((char) c);
+            }
+        }
+    }
+
+    private char mapNullToDisabled(final Character c) {
+        return c == null ? DISABLED : c.charValue();
+    }
+
+    /**
+     * Returns the current line number
+     *
+     * @return the current line number
+     */
+    long getCurrentLineNumber() {
+        return in.getCurrentLineNumber();
+    }
+
+    // TODO escape handling needs more work
+    /**
+     * Handle an escape sequence.
+     * The current character must be the escape character.
+     * On return, the next character is available by calling {@link ExtendedBufferedReader#getLastChar()}
+     * on the input stream.
+     *
+     * @return the unescaped character (as an int) or {@link Constants#END_OF_STREAM} if char following the escape is
+     *      invalid.
+     * @throws IOException if there is a problem reading the stream or the end of stream is detected:
+     *      the escape character is not allowed at end of strem
+     */
+    int readEscape() throws IOException {
+        // the escape char has just been read (normally a backslash)
+        final int ch = in.read();
+        switch (ch) {
+        case 'r':
+            return CR;
+        case 'n':
+            return LF;
+        case 't':
+            return TAB;
+        case 'b':
+            return BACKSPACE;
+        case 'f':
+            return FF;
+        case CR:
+        case LF:
+        case FF: // TODO is this correct?
+        case TAB: // TODO is this correct? Do tabs need to be escaped?
+        case BACKSPACE: // TODO is this correct?
+            return ch;
+        case END_OF_STREAM:
+            throw new IOException("EOF whilst processing escape sequence");
+        default:
+            // Now check for meta-characters
+            if (isMetaChar(ch)) {
+                return ch;
+            }
+            // indicate unexpected char - available from in.getLastChar()
+            return END_OF_STREAM;
+        }
+    }
+
+    void trimTrailingSpaces(final StringBuilder buffer) {
+        int length = buffer.length();
+        while (length > 0 && Character.isWhitespace(buffer.charAt(length - 1))) {
+            length = length - 1;
+        }
+        if (length != buffer.length()) {
+            buffer.setLength(length);
+        }
+    }
+
+    /**
+     * Greedily accepts \n, \r and \r\n This checker consumes silently the second control-character...
+     *
+     * @return true if the given or next character is a line-terminator
+     */
+    boolean readEndOfLine(int ch) throws IOException {
+        // check if we have \r\n...
+        if (ch == CR && in.lookAhead() == LF) {
+            // note: does not change ch outside of this method!
+            ch = in.read();
+        }
+        return ch == LF || ch == CR;
+    }
+
+    boolean isClosed() {
+        return in.isClosed();
+    }
+
+    /**
+     * @return true if the given char is a whitespace character
+     */
+    boolean isWhitespace(final int ch) {
+        return !isDelimiter(ch) && Character.isWhitespace((char) ch);
+    }
+
+    /**
+     * Checks if the current character represents the start of a line: a CR, LF or is at the start of the file.
+     *
+     * @param ch the character to check
+     * @return true if the character is at the start of a line.
+     */
+    boolean isStartOfLine(final int ch) {
+        return ch == LF || ch == CR || ch == UNDEFINED;
+    }
+
+    /**
+     * @return true if the given character indicates end of file
+     */
+    boolean isEndOfFile(final int ch) {
+        return ch == END_OF_STREAM;
+    }
+
+    boolean isDelimiter(final int ch) {
+        return ch == delimiter;
+    }
+
+    boolean isEscape(final int ch) {
+        return ch == escape;
+    }
+
+    boolean isQuoteChar(final int ch) {
+        return ch == quoteChar;
+    }
+
+    boolean isCommentStart(final int ch) {
+        return ch == commentStart;
+    }
+
+    private boolean isMetaChar(final int ch) {
+        return ch == delimiter ||
+               ch == escape ||
+               ch == quoteChar ||
+               ch == commentStart;
+    }
+
+    /**
+     * Closes resources.
+     *
+     * @throws IOException
+     *             If an I/O error occurs
+     */
+    void close() throws IOException {
+        in.close();
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/738619db/phoenix-core/src/main/java/org/apache/commons/csv/Quote.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/commons/csv/Quote.java b/phoenix-core/src/main/java/org/apache/commons/csv/Quote.java
new file mode 100644
index 0000000..774da96
--- /dev/null
+++ b/phoenix-core/src/main/java/org/apache/commons/csv/Quote.java
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.commons.csv;
+
+/**
+ * Defines quote behavior when printing.
+ *
+ * @version $Id: Quote.java 1465441 2013-04-07 18:38:56Z britter $
+ */
+public enum Quote {
+
+    /**
+     * Quotes all fields.
+     */
+    ALL,
+
+    /**
+     * Quotes fields which contain special characters such as a delimiter, quote character or any of the characters in
+     * line separator.
+     */
+    MINIMAL,
+
+    /**
+     * Quotes all non-numeric fields.
+     */
+    NON_NUMERIC,
+
+    /**
+     * Never quotes fields. When the delimiter occurs in data, it is preceded by the current escape character. If the
+     * escape character is not set, printing will throw an exception if any characters that require escaping are
+     * encountered.
+     */
+    NONE
+}

http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/738619db/phoenix-core/src/main/java/org/apache/commons/csv/Token.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/commons/csv/Token.java b/phoenix-core/src/main/java/org/apache/commons/csv/Token.java
new file mode 100644
index 0000000..7049e67
--- /dev/null
+++ b/phoenix-core/src/main/java/org/apache/commons/csv/Token.java
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+package org.apache.commons.csv;
+
+import static org.apache.commons.csv.Token.Type.INVALID;
+
+/**
+ * Internal token representation.
+ * <p/>
+ * It is used as contract between the lexer and the parser.
+ *
+ * @version $Id: Token.java 1509069 2013-08-01 02:04:27Z ggregory $
+ */
+final class Token {
+
+    /** length of the initial token (content-)buffer */
+    private static final int INITIAL_TOKEN_LENGTH = 50;
+
+    enum Type {
+        /** Token has no valid content, i.e. is in its initialized state. */
+        INVALID,
+
+        /** Token with content, at beginning or in the middle of a line. */
+        TOKEN,
+
+        /** Token (which can have content) when the end of file is reached. */
+        EOF,
+
+        /** Token with content when the end of a line is reached. */
+        EORECORD,
+
+        /** Token is a comment line. */
+        COMMENT
+    }
+
+    /** Token type */
+    Token.Type type = INVALID;
+
+    /** The content buffer. */
+    final StringBuilder content = new StringBuilder(INITIAL_TOKEN_LENGTH);
+
+    /** Token ready flag: indicates a valid token with content (ready for the parser). */
+    boolean isReady;
+
+    void reset() {
+        content.setLength(0);
+        type = INVALID;
+        isReady = false;
+    }
+
+    /**
+     * Eases IDE debugging.
+     *
+     * @return a string helpful for debugging.
+     */
+    @Override
+    public String toString() {
+        return type.name() + " [" + content.toString() + "]";
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/738619db/phoenix-core/src/main/java/org/apache/commons/csv/package-info.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/commons/csv/package-info.java b/phoenix-core/src/main/java/org/apache/commons/csv/package-info.java
new file mode 100644
index 0000000..29e7fef
--- /dev/null
+++ b/phoenix-core/src/main/java/org/apache/commons/csv/package-info.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+/**
+ * Apache Commons CSV Format Support.
+ *
+ * <p>CSV are widely used as interfaces to legacy systems or manual data-imports.
+ *    CSV stands for "Comma Separated Values" (or sometimes "Character Separated
+ *    Values"). The CSV data format is defined in
+ *    <a href="http://tools.ietf.org/html/rfc4180" target="_blank">RFC 4180</a>
+ *    but many dialects exist.</p>
+ *
+ * <p>Common to all file dialects is its basic structure: The CSV data-format
+ *    is record oriented, whereas each record starts on a new textual line. A
+ *    record is build of a list of values. Keep in mind that not all records
+ *    must have an equal number of values:</p>
+ * <pre>
+ *       csv    := records*
+ *       record := values*
+ * </pre>
+ *
+ * <p>The following list contains the CSV aspects the Commons CSV parser supports:</p>
+ * <dl>
+ *   <dt>Separators (for lines)</dt>
+ *   <dd>The record separators are hardcoded and cannot be changed. The must be '\r', '\n' or '\r\n'.</dd>
+ *
+ *   <dt>Delimiter (for values)</dt>
+ *   <dd>The delimiter for values is freely configurable (default ',').</dd>
+ *
+ *   <dt>Comments</dt>
+ *   <dd>Some CSV-dialects support a simple comment syntax. A comment is a record
+ *       which must start with a designated character (the commentStarter). A record
+ *       of this kind is treated as comment and gets removed from the input (default none)</dd>
+ *
+ *   <dt>Encapsulator</dt>
+ *  <dd>Two encapsulator characters (default '"') are used to enclose -&gt; complex values.</dd>
+ *
+ *   <dt>Simple values</dt>
+ *   <dd>A simple value consist of all characters (except the delimiter) until
+ *       (but not including) the next delimiter or a record-terminator. Optionally
+ *       all surrounding whitespaces of a simple value can be ignored (default: true).</dd>
+ *
+ *   <dt>Complex values</dt>
+ *   <dd>Complex values are encapsulated within a pair of the defined encapsulator characters.
+ *       The encapsulator itself must be escaped or doubled when used inside complex values.
+ *       Complex values preserve all kind of formatting (including newlines -&gt; multiline-values)</dd>
+ *
+ *  <dt>Empty line skipping</dt>
+ *   <dd>Optionally empty lines in CSV files can be skipped.
+ *       Otherwise, empty lines will return a record with a single empty value.</dd>
+ * </dl>
+ *
+ * <p>In addition to individually defined dialects, two predefined dialects (strict-csv, and excel-csv)
+ *    can be set directly.</p> <!-- TODO fix -->
+ *
+ * <p>Example usage:</p>
+ * <blockquote><pre>
+ * Reader in = new StringReader("a,b,c");
+ * for (CSVRecord record : CSVFormat.DEFAULT.parse(in)) {
+ *     for (String field : record) {
+ *         System.out.print("\"" + field + "\", ");
+ *     }
+ *     System.out.println();
+ * }
+ * </pre></blockquote>
+ */
+
+package org.apache.commons.csv;

http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/738619db/phoenix-core/src/main/java/org/apache/phoenix/util/CSVCommonsLoader.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/util/CSVCommonsLoader.java b/phoenix-core/src/main/java/org/apache/phoenix/util/CSVCommonsLoader.java
index 647b1dc..1947f53 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/util/CSVCommonsLoader.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/util/CSVCommonsLoader.java
@@ -36,8 +36,6 @@ import org.apache.phoenix.exception.SQLExceptionCode;
 import org.apache.phoenix.exception.SQLExceptionInfo;
 import org.apache.phoenix.jdbc.PhoenixConnection;
 import org.apache.phoenix.schema.PDataType;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import com.google.common.collect.Maps;
 
@@ -49,9 +47,6 @@ import com.google.common.collect.Maps;
  */
 public class CSVCommonsLoader {
 
-	private static final Logger logger = LoggerFactory
-			.getLogger(CSVCommonsLoader.class);
-
 	private final PhoenixConnection conn;
 	private final String tableName;
 	private final List<String> columns;

http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/738619db/phoenix-core/src/test/java/org/apache/phoenix/end2end/CSVCommonsLoaderTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/end2end/CSVCommonsLoaderTest.java b/phoenix-core/src/test/java/org/apache/phoenix/end2end/CSVCommonsLoaderTest.java
index b058020..5625580 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/end2end/CSVCommonsLoaderTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/end2end/CSVCommonsLoaderTest.java
@@ -204,7 +204,6 @@ public class CSVCommonsLoaderTest extends BaseHBaseManagedTimeTest {
 			ResultSet phoenixResultSet = statement.executeQuery();
 			parser = new CSVParser(new StringReader(
 					STOCK_CSV_VALUES_WITH_DELIMITER), csvUtil.getFormat());
-			String[] csvData;
 			for (CSVRecord record : parser) {
 				assertTrue(phoenixResultSet.next());
 				int i = 0;