ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From voze...@apache.org
Subject [50/58] [abbrv] incubator-ignite git commit: Merge branch 'sprint-1' into ignite-188
Date Fri, 06 Feb 2015 20:48:12 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/jdbc/JdbcResultSet.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/jdbc/JdbcResultSet.java
index 8677312,0000000..9d7adcf
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/jdbc/JdbcResultSet.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/jdbc/JdbcResultSet.java
@@@ -1,1519 -1,0 +1,1519 @@@
 +/*
 + * 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.ignite.internal.jdbc;
 +
 +import org.apache.ignite.client.*;
 +import org.apache.ignite.internal.util.typedef.internal.*;
 +
 +import java.io.*;
 +import java.math.*;
 +import java.net.*;
 +import java.sql.*;
 +import java.sql.Date;
 +import java.util.*;
 +
 +/**
 + * JDBC result set implementation.
 + */
 +public class JdbcResultSet implements ResultSet {
 +    /** Task name. */
 +    private static final String TASK_NAME =
 +        "org.apache.ignite.internal.processors.cache.query.jdbc.GridCacheQueryJdbcTask";
 +
 +    /** Statement. */
 +    private final JdbcStatement stmt;
 +
 +    /** Node ID. */
 +    private final UUID nodeId;
 +
 +    /** Future ID. */
 +    private final UUID futId;
 +
 +    /** Table names. */
 +    private final List<String> tbls;
 +
 +    /** Column names. */
 +    private final List<String> cols;
 +
 +    /** Class names. */
 +    private final List<String> types;
 +
 +    /** Fields iterator. */
 +    private Iterator<List<Object>> fields;
 +
 +    /** Finished flag. */
 +    private boolean finished;
 +
 +    /** Current position. */
 +    private int pos;
 +
 +    /** Current. */
 +    private List<Object> curr;
 +
 +    /** Closed flag. */
 +    private boolean closed;
 +
 +    /** Was {@code NULL} flag. */
 +    private boolean wasNull;
 +
 +    /** Fetch size. */
 +    private int fetchSize;
 +
 +    /**
 +     * Creates new result set.
 +     *
 +     * @param stmt Statement.
 +     * @param nodeId Node ID.
 +     * @param futId Future ID.
 +     * @param tbls Table names.
 +     * @param cols Column names.
 +     * @param types Types.
 +     * @param fields Fields.
 +     * @param finished Finished flag.
 +     * @param fetchSize Fetch size.
 +     */
 +    JdbcResultSet(JdbcStatement stmt, UUID nodeId, UUID futId,
 +        List<String> tbls, List<String> cols, List<String> types,
 +        Collection<List<Object>> fields, boolean finished, int fetchSize) {
 +        assert stmt != null;
 +        assert nodeId != null;
 +        assert futId != null;
 +        assert tbls != null;
 +        assert cols != null;
 +        assert types != null;
 +        assert fields != null;
 +        assert fetchSize > 0;
 +
 +        this.stmt = stmt;
 +        this.nodeId = nodeId;
 +        this.futId = futId;
 +        this.tbls = tbls;
 +        this.cols = cols;
 +        this.types = types;
 +        this.fetchSize = fetchSize;
 +        this.fields = fields.iterator();
 +        this.finished = finished;
 +    }
 +
 +    /**
 +     * Creates new result set with predefined fields.
 +     * Result set created with this constructor will
 +     * never execute remote tasks.
 +     *
 +     * @param stmt Statement.
 +     * @param tbls Table names.
 +     * @param cols Column names.
 +     * @param types Types.
 +     * @param fields Fields.
 +     */
 +    JdbcResultSet(JdbcStatement stmt, List<String> tbls, List<String> cols,
 +        List<String> types, Collection<List<Object>> fields) {
 +        assert stmt != null;
 +        assert tbls != null;
 +        assert cols != null;
 +        assert types != null;
 +        assert fields != null;
 +
 +        this.stmt = stmt;
 +        this.tbls = tbls;
 +        this.cols = cols;
 +        this.types = types;
 +        this.fields = fields.iterator();
 +
 +        nodeId = null;
 +        futId = null;
 +
 +        // Prevent task execution.
 +        finished = true;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean next() throws SQLException {
 +        ensureNotClosed();
 +
 +        if (fields == null && !finished) {
 +            assert nodeId != null;
 +            assert futId != null;
 +
 +            try {
 +                GridClientCompute compute = stmt.connection().client().compute();
 +
 +                GridClientCompute prj = compute.projection(compute.node(nodeId));
 +
 +                byte[] packet = prj.execute(TASK_NAME, JdbcUtils.marshalArgument(
 +                    JdbcUtils.taskArgument(nodeId, futId, fetchSize, stmt.getMaxRows())));
 +
 +                byte status = packet[0];
 +                byte[] data = new byte[packet.length - 1];
 +
 +                U.arrayCopy(packet, 1, data, 0, data.length);
 +
 +                if (status == 1)
 +                    throw JdbcUtils.unmarshalError(data);
 +                else {
 +                    List<?> msg = JdbcUtils.unmarshal(data);
 +
 +                    assert msg.size() == 2;
 +
 +                    fields = ((Collection<List<Object>>)msg.get(0)).iterator();
 +                    finished = (Boolean)msg.get(1);
 +                }
 +            }
 +            catch (GridClientException e) {
-                 throw new SQLException("Failed to query GridGain.", e);
++                throw new SQLException("Failed to query Ignite.", e);
 +            }
 +        }
 +
 +        if (fields != null && fields.hasNext()) {
 +            curr = fields.next();
 +
 +            if (!fields.hasNext())
 +                fields = null;
 +
 +            pos++;
 +
 +            return true;
 +        }
 +        else {
 +            curr = null;
 +
 +            return false;
 +        }
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void close() throws SQLException {
 +        closed = true;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean wasNull() throws SQLException {
 +        return wasNull;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public String getString(int colIdx) throws SQLException {
 +        return getTypedValue(colIdx, String.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean getBoolean(int colIdx) throws SQLException {
 +        Boolean val = getTypedValue(colIdx, Boolean.class);
 +
 +        return val != null ? val : false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte getByte(int colIdx) throws SQLException {
 +        Byte val = getTypedValue(colIdx, Byte.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public short getShort(int colIdx) throws SQLException {
 +        Short val = getTypedValue(colIdx, Short.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getInt(int colIdx) throws SQLException {
 +        Integer val = getTypedValue(colIdx, Integer.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public long getLong(int colIdx) throws SQLException {
 +        Long val = getTypedValue(colIdx, Long.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public float getFloat(int colIdx) throws SQLException {
 +        Float val = getTypedValue(colIdx, Float.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public double getDouble(int colIdx) throws SQLException {
 +        Double val = getTypedValue(colIdx, Double.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public BigDecimal getBigDecimal(int colIdx, int scale) throws SQLException {
 +        return getTypedValue(colIdx, BigDecimal.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte[] getBytes(int colIdx) throws SQLException {
 +        return getTypedValue(colIdx, byte[].class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Date getDate(int colIdx) throws SQLException {
 +        return getTypedValue(colIdx, Date.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Time getTime(int colIdx) throws SQLException {
 +        return getTypedValue(colIdx, Time.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Timestamp getTimestamp(int colIdx) throws SQLException {
 +        return getTypedValue(colIdx, Timestamp.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public InputStream getAsciiStream(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Streams are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public InputStream getUnicodeStream(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Streams are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public InputStream getBinaryStream(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Stream are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public String getString(String colLb) throws SQLException {
 +        return getTypedValue(colLb, String.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean getBoolean(String colLb) throws SQLException {
 +        Boolean val = getTypedValue(colLb, Boolean.class);
 +
 +        return val != null ? val : false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte getByte(String colLb) throws SQLException {
 +        Byte val = getTypedValue(colLb, Byte.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public short getShort(String colLb) throws SQLException {
 +        Short val = getTypedValue(colLb, Short.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getInt(String colLb) throws SQLException {
 +        Integer val = getTypedValue(colLb, Integer.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public long getLong(String colLb) throws SQLException {
 +        Long val = getTypedValue(colLb, Long.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public float getFloat(String colLb) throws SQLException {
 +        Float val = getTypedValue(colLb, Float.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public double getDouble(String colLb) throws SQLException {
 +        Double val = getTypedValue(colLb, Double.class);
 +
 +        return val != null ? val : 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public BigDecimal getBigDecimal(String colLb, int scale) throws SQLException {
 +        return getTypedValue(colLb, BigDecimal.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte[] getBytes(String colLb) throws SQLException {
 +        return getTypedValue(colLb, byte[].class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Date getDate(String colLb) throws SQLException {
 +        return getTypedValue(colLb, Date.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Time getTime(String colLb) throws SQLException {
 +        return getTypedValue(colLb, Time.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Timestamp getTimestamp(String colLb) throws SQLException {
 +        return getTypedValue(colLb, Timestamp.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public InputStream getAsciiStream(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Streams are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public InputStream getUnicodeStream(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Streams are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public InputStream getBinaryStream(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Streams are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public SQLWarning getWarnings() throws SQLException {
 +        ensureNotClosed();
 +
 +        return null;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void clearWarnings() throws SQLException {
 +        ensureNotClosed();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public String getCursorName() throws SQLException {
 +        ensureNotClosed();
 +
 +        return null;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public ResultSetMetaData getMetaData() throws SQLException {
 +        ensureNotClosed();
 +
 +        return new JdbcResultSetMetadata(tbls, cols, types);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Object getObject(int colIdx) throws SQLException {
 +        return getTypedValue(colIdx, Object.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Object getObject(String colLb) throws SQLException {
 +        return getTypedValue(colLb, Object.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int findColumn(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        int idx = cols.indexOf(colLb.toUpperCase());
 +
 +        if (idx == -1)
 +            throw new SQLException("Column not found: " + colLb);
 +
 +        return idx + 1;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Reader getCharacterStream(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Streams are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Reader getCharacterStream(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Streams are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public BigDecimal getBigDecimal(int colIdx) throws SQLException {
 +        return getTypedValue(colIdx, BigDecimal.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public BigDecimal getBigDecimal(String colLb) throws SQLException {
 +        return getTypedValue(colLb, BigDecimal.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isBeforeFirst() throws SQLException {
 +        ensureNotClosed();
 +
 +        return pos < 1;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isAfterLast() throws SQLException {
 +        ensureNotClosed();
 +
 +        return finished && fields == null && curr == null;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isFirst() throws SQLException {
 +        ensureNotClosed();
 +
 +        return pos == 1;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isLast() throws SQLException {
 +        ensureNotClosed();
 +
 +        return finished && fields == null && curr != null;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void beforeFirst() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLException("Result set is forward-only.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void afterLast() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLException("Result set is forward-only.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean first() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLException("Result set is forward-only.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean last() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLException("Result set is forward-only.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getRow() throws SQLException {
 +        ensureNotClosed();
 +
 +        return isAfterLast() ? 0 : pos;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean absolute(int row) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLException("Result set is forward-only.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean relative(int rows) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLException("Result set is forward-only.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean previous() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLException("Result set is forward-only.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setFetchDirection(int direction) throws SQLException {
 +        ensureNotClosed();
 +
 +        if (direction != FETCH_FORWARD)
 +            throw new SQLFeatureNotSupportedException("Only forward direction is supported");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getFetchDirection() throws SQLException {
 +        ensureNotClosed();
 +
 +        return FETCH_FORWARD;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setFetchSize(int fetchSize) throws SQLException {
 +        ensureNotClosed();
 +
 +        if (fetchSize <= 0)
 +            throw new SQLException("Fetch size must be greater than zero.");
 +
 +        this.fetchSize = fetchSize;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getFetchSize() throws SQLException {
 +        ensureNotClosed();
 +
 +        return fetchSize;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getType() throws SQLException {
 +        ensureNotClosed();
 +
 +        return stmt.getResultSetType();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getConcurrency() throws SQLException {
 +        ensureNotClosed();
 +
 +        return CONCUR_READ_ONLY;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean rowUpdated() throws SQLException {
 +        ensureNotClosed();
 +
 +        return false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean rowInserted() throws SQLException {
 +        ensureNotClosed();
 +
 +        return false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean rowDeleted() throws SQLException {
 +        ensureNotClosed();
 +
 +        return false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNull(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBoolean(int colIdx, boolean x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateByte(int colIdx, byte x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateShort(int colIdx, short x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateInt(int colIdx, int x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateLong(int colIdx, long x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateFloat(int colIdx, float x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateDouble(int colIdx, double x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBigDecimal(int colIdx, BigDecimal x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateString(int colIdx, String x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBytes(int colIdx, byte[] x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateDate(int colIdx, Date x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateTime(int colIdx, Time x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateTimestamp(int colIdx, Timestamp x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateAsciiStream(int colIdx, InputStream x, int len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBinaryStream(int colIdx, InputStream x, int len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateCharacterStream(int colIdx, Reader x, int len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateObject(int colIdx, Object x, int scaleOrLen) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateObject(int colIdx, Object x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNull(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBoolean(String colLb, boolean x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateByte(String colLb, byte x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateShort(String colLb, short x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateInt(String colLb, int x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateLong(String colLb, long x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateFloat(String colLb, float x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateDouble(String colLb, double x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBigDecimal(String colLb, BigDecimal x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateString(String colLb, String x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBytes(String colLb, byte[] x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateDate(String colLb, Date x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateTime(String colLb, Time x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateTimestamp(String colLb, Timestamp x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateAsciiStream(String colLb, InputStream x, int len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBinaryStream(String colLb, InputStream x, int len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateCharacterStream(String colLb, Reader reader, int len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateObject(String colLb, Object x, int scaleOrLen) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateObject(String colLb, Object x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void insertRow() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateRow() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void deleteRow() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void refreshRow() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Row refreshing is not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void cancelRowUpdates() throws SQLException {
 +        ensureNotClosed();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void moveToInsertRow() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void moveToCurrentRow() throws SQLException {
 +        ensureNotClosed();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Statement getStatement() throws SQLException {
 +        ensureNotClosed();
 +
 +        return stmt;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Object getObject(int colIdx, Map<String, Class<?>> map) throws SQLException {
 +        return getTypedValue(colIdx, Object.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Ref getRef(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Blob getBlob(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Clob getClob(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Array getArray(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Object getObject(String colLb, Map<String, Class<?>> map) throws SQLException {
 +        return getTypedValue(colLb, Object.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Ref getRef(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Blob getBlob(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Clob getClob(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Array getArray(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Date getDate(int colIdx, Calendar cal) throws SQLException {
 +        return getTypedValue(colIdx, Date.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Date getDate(String colLb, Calendar cal) throws SQLException {
 +        return getTypedValue(colLb, Date.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Time getTime(int colIdx, Calendar cal) throws SQLException {
 +        return getTypedValue(colIdx, Time.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Time getTime(String colLb, Calendar cal) throws SQLException {
 +        return getTypedValue(colLb, Time.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Timestamp getTimestamp(int colIdx, Calendar cal) throws SQLException {
 +        return getTypedValue(colIdx, Timestamp.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Timestamp getTimestamp(String colLb, Calendar cal) throws SQLException {
 +        return getTypedValue(colLb, Timestamp.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public URL getURL(int colIdx) throws SQLException {
 +        return getTypedValue(colIdx, URL.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public URL getURL(String colLb) throws SQLException {
 +        return getTypedValue(colLb, URL.class);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateRef(int colIdx, Ref x) throws SQLException {
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateRef(String colLb, Ref x) throws SQLException {
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBlob(int colIdx, Blob x) throws SQLException {
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBlob(String colLb, Blob x) throws SQLException {
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateClob(int colIdx, Clob x) throws SQLException {
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateClob(String colLb, Clob x) throws SQLException {
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateArray(int colIdx, Array x) throws SQLException {
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateArray(String colLb, Array x) throws SQLException {
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public RowId getRowId(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public RowId getRowId(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateRowId(int colIdx, RowId x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateRowId(String colLb, RowId x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getHoldability() throws SQLException {
 +        ensureNotClosed();
 +
 +        return HOLD_CURSORS_OVER_COMMIT;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isClosed() throws SQLException {
 +        return closed;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNString(int colIdx, String nStr) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNString(String colLb, String nStr) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNClob(int colIdx, NClob nClob) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNClob(String colLb, NClob nClob) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public NClob getNClob(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public NClob getNClob(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public SQLXML getSQLXML(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public SQLXML getSQLXML(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateSQLXML(int colIdx, SQLXML xmlObj) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateSQLXML(String colLb, SQLXML xmlObj) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public String getNString(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public String getNString(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Reader getNCharacterStream(int colIdx) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Reader getNCharacterStream(String colLb) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNCharacterStream(int colIdx, Reader x, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNCharacterStream(String colLb, Reader reader, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateAsciiStream(int colIdx, InputStream x, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBinaryStream(int colIdx, InputStream x, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateCharacterStream(int colIdx, Reader x, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateAsciiStream(String colLb, InputStream x, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBinaryStream(String colLb, InputStream x, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateCharacterStream(String colLb, Reader reader, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBlob(int colIdx, InputStream inputStream, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBlob(String colLb, InputStream inputStream, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateClob(int colIdx, Reader reader, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateClob(String colLb, Reader reader, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNClob(int colIdx, Reader reader, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNClob(String colLb, Reader reader, long len) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNCharacterStream(int colIdx, Reader x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNCharacterStream(String colLb, Reader reader) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateAsciiStream(int colIdx, InputStream x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBinaryStream(int colIdx, InputStream x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateCharacterStream(int colIdx, Reader x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateAsciiStream(String colLb, InputStream x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBinaryStream(String colLb, InputStream x) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateCharacterStream(String colLb, Reader reader) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBlob(int colIdx, InputStream inputStream) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateBlob(String colLb, InputStream inputStream) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateClob(int colIdx, Reader reader) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateClob(String colLb, Reader reader) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNClob(int colIdx, Reader reader) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void updateNClob(String colLb, Reader reader) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public <T> T unwrap(Class<T> iface) throws SQLException {
 +        if (!isWrapperFor(iface))
 +            throw new SQLException("Result set is not a wrapper for " + iface.getName());
 +
 +        return (T)this;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isWrapperFor(Class<?> iface) throws SQLException {
 +        return iface != null && iface == ResultSet.class;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public <T> T getObject(int colIdx, Class<T> type) throws SQLException {
 +        return getTypedValue(colIdx, type);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public <T> T getObject(String colLb, Class<T> type) throws SQLException {
 +        return getTypedValue(colLb, type);
 +    }
 +
 +    /**
 +     * Gets casted field value by label.
 +     *
 +     * @param colLb Column label.
 +     * @param cls Value class.
 +     * @return Casted field value.
 +     * @throws SQLException In case of error.
 +     */
 +    private <T> T getTypedValue(String colLb, Class<T> cls) throws SQLException {
 +        ensureNotClosed();
 +        ensureHasCurrentRow();
 +
 +        int colIdx = cols.indexOf(colLb.toUpperCase()) + 1;
 +
 +        if (colIdx <= 0)
 +            throw new SQLException("Invalid column label: " + colLb);
 +
 +        return getTypedValue(colIdx, cls);
 +    }
 +
 +    /**
 +     * Gets casted field value by index.
 +     *
 +     * @param colIdx Column index.
 +     * @param cls Value class.
 +     * @return Casted field value.
 +     * @throws SQLException In case of error.
 +     */
 +    private <T> T getTypedValue(int colIdx, Class<T> cls) throws SQLException {
 +        ensureNotClosed();
 +        ensureHasCurrentRow();
 +
 +        try {
 +            T val = cls == String.class ? (T)String.valueOf(curr.get(colIdx - 1)) : (T)curr.get(colIdx - 1);
 +
 +            wasNull = val == null;
 +
 +            return val;
 +        }
 +        catch (IndexOutOfBoundsException ignored) {
 +            throw new SQLException("Invalid column index: " + colIdx);
 +        }
 +        catch (ClassCastException ignored) {
 +            throw new SQLException("Value is an not instance of " + cls.getName());
 +        }
 +    }
 +
 +    /**
 +     * Ensures that result set is not closed.
 +     *
 +     * @throws SQLException If result set is closed.
 +     */
 +    private void ensureNotClosed() throws SQLException {
 +        if (closed)
 +            throw new SQLException("Result set is closed.");
 +    }
 +
 +    /**
 +     * Ensures that result set is positioned on a row.
 +     *
 +     * @throws SQLException If result set is not positioned on a row.
 +     */
 +    private void ensureHasCurrentRow() throws SQLException {
 +        if (curr == null)
 +            throw new SQLException("Result set is not positioned on a row.");
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/jdbc/JdbcStatement.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/jdbc/JdbcStatement.java
index 84fdf93,0000000..3ef60af
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/jdbc/JdbcStatement.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/jdbc/JdbcStatement.java
@@@ -1,448 -1,0 +1,448 @@@
 +/*
 + * 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.ignite.internal.jdbc;
 +
 +import org.apache.ignite.client.*;
 +import org.apache.ignite.internal.util.typedef.internal.*;
 +
 +import java.sql.*;
 +import java.util.*;
 +
 +import static java.sql.ResultSet.*;
 +
 +/**
 + * JDBC statement implementation.
 + */
 +public class JdbcStatement implements Statement {
 +    /** Task name. */
 +    private static final String TASK_NAME =
 +        "org.apache.ignite.internal.processors.cache.query.jdbc.GridCacheQueryJdbcTask";
 +
 +    /** Default fetch size. */
 +    private static final int DFLT_FETCH_SIZE = 1024;
 +
 +    /** Connection. */
 +    private final JdbcConnection conn;
 +
 +    /** Closed flag. */
 +    private boolean closed;
 +
 +    /** Rows limit. */
 +    private int maxRows;
 +
 +    /** Query timeout. */
 +    private int timeout;
 +
 +    /** Current result set. */
 +    private ResultSet rs;
 +
 +    /** Query arguments. */
 +    protected Object[] args;
 +
 +    /** Fetch size. */
 +    private int fetchSize = DFLT_FETCH_SIZE;
 +
 +    /**
 +     * Creates new statement.
 +     *
 +     * @param conn Connection.
 +     */
 +    JdbcStatement(JdbcConnection conn) {
 +        assert conn != null;
 +
 +        this.conn = conn;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public ResultSet executeQuery(String sql) throws SQLException {
 +        ensureNotClosed();
 +
 +        rs = null;
 +
 +        if (sql == null || sql.isEmpty())
 +            throw new SQLException("SQL query is empty");
 +
 +        try {
 +            byte[] packet = conn.client().compute().execute(TASK_NAME,
 +                JdbcUtils.marshalArgument(JdbcUtils.taskArgument(conn.nodeId(), conn.cacheName(), sql,
 +                    timeout, args, fetchSize, maxRows)));
 +
 +            byte status = packet[0];
 +            byte[] data = new byte[packet.length - 1];
 +
 +            U.arrayCopy(packet, 1, data, 0, data.length);
 +
 +            if (status == 1)
 +                throw JdbcUtils.unmarshalError(data);
 +            else {
 +                List<?> msg = JdbcUtils.unmarshal(data);
 +
 +                assert msg.size() == 7;
 +
 +                UUID nodeId = (UUID)msg.get(0);
 +                UUID futId = (UUID)msg.get(1);
 +                List<String> tbls = (List<String>)msg.get(2);
 +                List<String> cols = (List<String>)msg.get(3);
 +                List<String> types = (List<String>)msg.get(4);
 +                Collection<List<Object>> fields = (Collection<List<Object>>)msg.get(5);
 +                boolean finished = (Boolean)msg.get(6);
 +
 +                return new JdbcResultSet(this, nodeId, futId, tbls, cols, types, fields, finished, fetchSize);
 +            }
 +        }
 +        catch (GridClientException e) {
-             throw new SQLException("Failed to query GridGain.", e);
++            throw new SQLException("Failed to query Ignite.", e);
 +        }
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int executeUpdate(String sql) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void close() throws SQLException {
 +        closed = true;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getMaxFieldSize() throws SQLException {
 +        ensureNotClosed();
 +
 +        return 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setMaxFieldSize(int max) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Field size limitation is not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getMaxRows() throws SQLException {
 +        ensureNotClosed();
 +
 +        return maxRows;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setMaxRows(int maxRows) throws SQLException {
 +        ensureNotClosed();
 +
 +        this.maxRows = maxRows;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setEscapeProcessing(boolean enable) throws SQLException {
 +        ensureNotClosed();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getQueryTimeout() throws SQLException {
 +        ensureNotClosed();
 +
 +        return timeout;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setQueryTimeout(int timeout) throws SQLException {
 +        ensureNotClosed();
 +
 +        this.timeout = timeout * 1000;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void cancel() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Cancellation is not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public SQLWarning getWarnings() throws SQLException {
 +        ensureNotClosed();
 +
 +        return null;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void clearWarnings() throws SQLException {
 +        ensureNotClosed();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setCursorName(String name) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean execute(String sql) throws SQLException {
 +        ensureNotClosed();
 +
 +        rs = executeQuery(sql);
 +
 +        return true;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public ResultSet getResultSet() throws SQLException {
 +        ensureNotClosed();
 +
 +        ResultSet rs0 = rs;
 +
 +        rs = null;
 +
 +        return rs0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getUpdateCount() throws SQLException {
 +        ensureNotClosed();
 +
 +        return -1;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean getMoreResults() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Multiple open results are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setFetchDirection(int direction) throws SQLException {
 +        ensureNotClosed();
 +
 +        if (direction != FETCH_FORWARD)
 +            throw new SQLFeatureNotSupportedException("Only forward direction is supported");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getFetchDirection() throws SQLException {
 +        ensureNotClosed();
 +
 +        return FETCH_FORWARD;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setFetchSize(int fetchSize) throws SQLException {
 +        ensureNotClosed();
 +
 +        if (fetchSize <= 0)
 +            throw new SQLException("Fetch size must be greater than zero.");
 +
 +        this.fetchSize = fetchSize;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getFetchSize() throws SQLException {
 +        ensureNotClosed();
 +
 +        return fetchSize;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getResultSetConcurrency() throws SQLException {
 +        ensureNotClosed();
 +
 +        return CONCUR_READ_ONLY;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getResultSetType() throws SQLException {
 +        ensureNotClosed();
 +
 +        return TYPE_FORWARD_ONLY;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void addBatch(String sql) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void clearBatch() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int[] executeBatch() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public Connection getConnection() throws SQLException {
 +        ensureNotClosed();
 +
 +        return conn;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean getMoreResults(int curr) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Multiple open results are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public ResultSet getGeneratedKeys() throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int executeUpdate(String sql, int[] colIndexes) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int executeUpdate(String sql, String[] colNames) throws SQLException {
 +        ensureNotClosed();
 +
 +        throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
 +        ensureNotClosed();
 +
 +        if (autoGeneratedKeys == RETURN_GENERATED_KEYS)
 +            throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +
 +        return execute(sql);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean execute(String sql, int[] colIndexes) throws SQLException {
 +        ensureNotClosed();
 +
 +        if (colIndexes != null && colIndexes.length > 0)
 +            throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +
 +        return execute(sql);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean execute(String sql, String[] colNames) throws SQLException {
 +        ensureNotClosed();
 +
 +        if (colNames != null && colNames.length > 0)
 +            throw new SQLFeatureNotSupportedException("Updates are not supported.");
 +
 +        return execute(sql);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int getResultSetHoldability() throws SQLException {
 +        ensureNotClosed();
 +
 +        return HOLD_CURSORS_OVER_COMMIT;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isClosed() throws SQLException {
 +        return closed;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setPoolable(boolean poolable) throws SQLException {
 +        ensureNotClosed();
 +
 +        if (poolable)
 +            throw new SQLFeatureNotSupportedException("Pooling is not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isPoolable() throws SQLException {
 +        ensureNotClosed();
 +
 +        return false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public <T> T unwrap(Class<T> iface) throws SQLException {
 +        if (!isWrapperFor(iface))
 +            throw new SQLException("Statement is not a wrapper for " + iface.getName());
 +
 +        return (T)this;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isWrapperFor(Class<?> iface) throws SQLException {
 +        return iface != null && iface == Statement.class;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void closeOnCompletion() throws SQLException {
 +        throw new SQLFeatureNotSupportedException("closeOnCompletion is not supported.");
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isCloseOnCompletion() throws SQLException {
 +        ensureNotClosed();
 +
 +        return false;
 +    }
 +
 +    /**
 +     * Sets timeout in milliseconds.
 +     *
 +     * @param timeout Timeout.
 +     */
 +    void timeout(int timeout) {
 +        this.timeout = timeout;
 +    }
 +
 +    /**
 +     * @return Connection.
 +     */
 +    JdbcConnection connection() {
 +        return conn;
 +    }
 +
 +    /**
 +     * Ensures that statement is not closed.
 +     *
 +     * @throws SQLException If statement is closed.
 +     */
 +    protected void ensureNotClosed() throws SQLException {
 +        if (closed)
 +            throw new SQLException("Statement is closed.");
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/managers/GridManagerAdapter.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/managers/eventstorage/GridEventStorageManager.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAttributes.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheUtils.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsContext.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/GridGgfsImpl.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/processors/fs/IgniteFsProcessor.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/protocols/tcp/GridTcpRestParser.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/protocols/tcp/GridTcpRestProtocol.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/util/lang/GridFunc.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorCacheConfiguration.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/internal/visor/util/VisorTaskUtils.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/lifecycle/LifecycleBean.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/logger/LoggerNodeIdAware.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/logger/LoggerNodeIdAware.java
index 1250436,0000000..8a5db87
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/logger/LoggerNodeIdAware.java
+++ b/modules/core/src/main/java/org/apache/ignite/logger/LoggerNodeIdAware.java
@@@ -1,39 -1,0 +1,39 @@@
 +/*
 + * 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.ignite.logger;
 +
 +import java.util.*;
 +
 +/**
-  * Interface for GridGain file appenders to attach node ID to log file names.
++ * Interface for Ignite file appenders to attach node ID to log file names.
 + */
 +public interface LoggerNodeIdAware {
 +    /**
 +     * Sets node ID.
 +     *
 +     * @param nodeId Node ID.
 +     */
 +    public void setNodeId(UUID nodeId);
 +
 +    /**
 +     * Gets node ID.
 +     *
 +     * @return Node ID.
 +     */
 +    public UUID getNodeId();
 +}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/logger/java/JavaLogger.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/logger/java/JavaLogger.java
index cb4c450,0000000..a9e3d0a
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/logger/java/JavaLogger.java
+++ b/modules/core/src/main/java/org/apache/ignite/logger/java/JavaLogger.java
@@@ -1,388 -1,0 +1,388 @@@
 +/*
 + * 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.ignite.logger.java;
 +
 +import org.apache.ignite.*;
 +import org.apache.ignite.internal.util.typedef.*;
 +import org.apache.ignite.internal.util.typedef.internal.*;
 +import org.apache.ignite.logger.*;
 +import org.jetbrains.annotations.*;
 +
 +import java.io.*;
 +import java.net.*;
 +import java.util.*;
 +import java.util.logging.*;
 +
 +import static java.util.logging.Level.*;
 +import static org.apache.ignite.IgniteSystemProperties.*;
 +
 +/**
 + * Logger to use with Java logging. Implementation simply delegates to Java Logging.
 + * <p>
-  * Here is an example of configuring Java logger in GridGain configuration Spring
++ * Here is an example of configuring Java logger in Ignite configuration Spring
 + * file to work over log4j implementation. Note that we use the same configuration file
 + * as we provide by default:
 + * <pre name="code" class="xml">
 + *      ...
 + *      &lt;property name="gridLogger"&gt;
-  *          &lt;bean class="org.gridgain.grid.logger.java.GridJavaLogger"&gt;
++ *          &lt;bean class="org.apache.ignite.logger.java.IgniteJavaLogger"&gt;
 + *              &lt;constructor-arg type="java.util.logging.Logger"&gt;
 + *                  &lt;bean class="java.util.logging.Logger"&gt;
 + *                      &lt;constructor-arg type="java.lang.String" value="global"/&gt;
 + *                  &lt;/bean&gt;
 + *              &lt;/constructor-arg&gt;
 + *          &lt;/bean&gt;
 + *      &lt;/property&gt;
 + *      ...
 + * </pre>
 + * or
 + * <pre name="code" class="xml">
 + *      ...
 + *      &lt;property name="gridLogger"&gt;
-  *          &lt;bean class="org.gridgain.grid.logger.java.GridJavaLogger"/&gt;
++ *          &lt;bean class="org.apache.ignite.logger.java.IgniteJavaLogger"/&gt;
 + *      &lt;/property&gt;
 + *      ...
 + * </pre>
-  * And the same configuration if you'd like to configure GridGain in your code:
++ * And the same configuration if you'd like to configure Ignite in your code:
 + * <pre name="code" class="java">
 + *      GridConfiguration cfg = new GridConfiguration();
 + *      ...
 + *      GridLogger log = new GridJavaLogger(Logger.global);
 + *      ...
 + *      cfg.setGridLogger(log);
 + * </pre>
 + * or which is actually the same:
 + * <pre name="code" class="java">
 + *      GridConfiguration cfg = new GridConfiguration();
 + *      ...
 + *      GridLogger log = new GridJavaLogger();
 + *      ...
 + *      cfg.setGridLogger(log);
 + * </pre>
 + * Please take a look at <a target=_new href="http://java.sun.com/j2se/1.4.2/docs/api20/java/util/logging/Logger.html">Logger javadoc</a>
 + * for additional information.
 + * <p>
-  * It's recommended to use GridGain logger injection instead of using/instantiating
++ * It's recommended to use Ignite logger injection instead of using/instantiating
 + * logger in your task/job code. See {@link org.apache.ignite.resources.LoggerResource} annotation about logger
 + * injection.
 + */
 +public class JavaLogger implements IgniteLogger, LoggerNodeIdAware {
 +    /** */
 +    private static final long serialVersionUID = 0L;
 +
 +    /** */
 +    public static final String DFLT_CONFIG_PATH = "config/java.util.logging.properties";
 +
 +    /** */
 +    private static final Object mux = new Object();
 +
 +    /** */
 +    private static volatile boolean inited;
 +
 +    /** */
 +    private static volatile boolean quiet0;
 +
 +    /** Java Logging implementation proxy. */
 +    @SuppressWarnings("FieldAccessedSynchronizedAndUnsynchronized")
 +    private Logger impl;
 +
 +    /** Quiet flag. */
 +    private final boolean quiet;
 +
 +    /** Node ID. */
 +    private volatile UUID nodeId;
 +
 +    /**
 +     * Creates new logger.
 +     */
 +    public JavaLogger() {
 +        this(!isConfigured());
 +    }
 +
 +    /**
 +     * Checks if logger is already configured within this VM or not.
 +     *
 +     * @return {@code True} if logger was already configured, {@code false} otherwise.
 +     */
 +    public static boolean isConfigured() {
 +        return System.getProperty("java.util.logging.config.file") != null;
 +    }
 +
 +    /**
 +     * Reads default JUL configuration.
 +     */
 +    private void defaultConfiguration() {
-         final URL cfgUrl = U.resolveGridGainUrl(DFLT_CONFIG_PATH);
++        final URL cfgUrl = U.resolveIgniteUrl(DFLT_CONFIG_PATH);
 +
 +        if (cfgUrl == null) {
 +            error("Failed to resolve default logging config file: " + DFLT_CONFIG_PATH);
 +
 +            return;
 +        }
 +
 +        try (InputStream in = cfgUrl.openStream()) {
 +            LogManager.getLogManager().readConfiguration(in);
 +        }
 +        catch (IOException e) {
 +            error("Failed to read logging configuration: " + cfgUrl, e);
 +        }
 +    }
 +
 +    /**
 +     * Creates new logger.
 +     *
 +     * @param init If {@code true}, then a default console appender will be created.
 +     *      If {@code false}, then no implicit initialization will take place,
 +     *      and java logger should be configured prior to calling this constructor.
 +     */
 +    public JavaLogger(boolean init) {
 +        impl = Logger.getLogger("");
 +
 +        if (init) {
 +            // Implementation has already been inited, passing NULL.
 +            configure(null);
 +
 +            quiet = quiet0;
 +        }
 +        else
 +            quiet = true;
 +    }
 +
 +    /**
 +     * Creates new logger with given implementation.
 +     *
 +     * @param impl Java Logging implementation to use.
 +     */
 +    public JavaLogger(final Logger impl) {
 +        assert impl != null;
 +
 +        configure(impl);
 +
 +        quiet = quiet0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public IgniteLogger getLogger(Object ctgr) {
 +        return new JavaLogger(ctgr == null ? Logger.getLogger("") : Logger.getLogger(
 +            ctgr instanceof Class ? ((Class)ctgr).getName() : String.valueOf(ctgr)));
 +    }
 +
 +    /**
 +     * Configures handlers when needed.
 +     *
 +     * @param initImpl Optional log implementation.
 +     */
 +    private void configure(@Nullable Logger initImpl) {
 +        if (initImpl != null)
 +            impl = initImpl;
 +
 +        if (inited)
 +            return;
 +
 +        synchronized (mux) {
 +            if (inited)
 +                return;
 +
 +            if (isConfigured()) {
 +                boolean consoleHndFound = findHandler(impl, ConsoleHandler.class) != null;
 +
 +                // User configured console appender, thus log is not quiet.
 +                quiet0 = !consoleHndFound;
 +                inited = true;
 +
 +                return;
 +            }
 +
 +            defaultConfiguration();
 +
 +            boolean quiet = Boolean.valueOf(System.getProperty(IGNITE_QUIET, "true"));
 +            boolean useConsoleAppender = Boolean.valueOf(System.getProperty(IGNITE_CONSOLE_APPENDER, "true"));
 +
 +            if (useConsoleAppender) {
 +                ConsoleHandler consoleHnd = findHandler(impl, ConsoleHandler.class);
 +
 +                if (consoleHnd != null)
 +                    consoleHnd.setLevel(quiet ? SEVERE : INFO);
 +                else
 +                    System.err.println("Console logging handler is not configured.");
 +            }
 +            else {
 +                Handler[] handlers = Logger.getLogger("").getHandlers();
 +
 +                if  (!F.isEmpty(handlers)) {
 +                    for (Handler h : handlers) {
 +                        if (h instanceof ConsoleHandler)
 +                            impl.removeHandler(h);
 +                    }
 +                }
 +            }
 +
 +            quiet0 = quiet;
 +            inited = true;
 +        }
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void trace(String msg) {
 +        if (!impl.isLoggable(FINEST))
 +            warning("Logging at TRACE level without checking if TRACE level is enabled: " + msg);
 +
 +        impl.finest(msg);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void debug(String msg) {
 +        if (!impl.isLoggable(FINE))
 +            warning("Logging at DEBUG level without checking if DEBUG level is enabled: " + msg);
 +
 +        impl.fine(msg);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void info(String msg) {
 +        if (!impl.isLoggable(INFO))
 +            warning("Logging at INFO level without checking if INFO level is enabled: " + msg);
 +
 +        impl.info(msg);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void warning(String msg) {
 +        impl.warning(msg);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void warning(String msg, @Nullable Throwable e) {
 +        impl.log(WARNING, msg, e);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void error(String msg) {
 +        impl.severe(msg);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isQuiet() {
 +        return quiet;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void error(String msg, @Nullable Throwable e) {
 +        impl.log(SEVERE, msg, e);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isTraceEnabled() {
 +        return impl.isLoggable(FINEST);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isDebugEnabled() {
 +        return impl.isLoggable(FINE);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isInfoEnabled() {
 +        return impl.isLoggable(INFO);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Nullable @Override public String fileName() {
 +        JavaLoggerFileHandler gridFileHnd = findHandler(impl, JavaLoggerFileHandler.class);
 +
 +        if (gridFileHnd != null)
 +            return gridFileHnd.fileName();
 +
 +        FileHandler fileHnd = findHandler(impl, FileHandler.class);
 +
 +        return fileName(fileHnd);
 +    }
 +
 +    /**
 +     * @param fileHnd File handler.
 +     * @return Current log file or {@code null} if it can not be retrieved from file handler.
 +     */
 +    @Nullable static String fileName(FileHandler fileHnd) {
 +        if (fileHnd == null)
 +            return null;
 +
 +        try {
 +            File[] logFiles = U.field(fileHnd, "files");
 +
 +            return logFiles[0].getAbsolutePath();
 +        }
 +        catch (Exception ignored) {
 +            return null;
 +        }
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void setNodeId(UUID nodeId) {
 +        A.notNull(nodeId, "nodeId");
 +
 +        if (this.nodeId != null)
 +            return;
 +
 +        synchronized (mux) {
 +            // Double check.
 +            if (this.nodeId != null)
 +                return;
 +
 +            this.nodeId = nodeId;
 +        }
 +
 +        JavaLoggerFileHandler fileHnd = findHandler(impl, JavaLoggerFileHandler.class);
 +
 +        if (fileHnd == null)
 +            return;
 +
 +        try {
 +            fileHnd.nodeId(nodeId);
 +        }
 +        catch (IgniteCheckedException | IOException e) {
 +            throw new RuntimeException("Failed to enable file handler.", e);
 +        }
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public UUID getNodeId() {
 +        return nodeId;
 +    }
 +
 +    /**
 +     * Returns first found handler of specified class type or {@code null} if that handler isn't configured.
 +     *
 +     * @param log Logger.
 +     * @param cls Class.
 +     * @param <T> Class type.
 +     * @return First found handler of specified class type or {@code null} if that handler isn't configured.
 +     */
 +    @SuppressWarnings("unchecked")
 +    private static <T> T findHandler(Logger log, Class<T> cls) {
 +        while (log != null) {
 +            for (Handler hnd : log.getHandlers()) {
 +                if (cls.isInstance(hnd))
 +                    return (T)hnd;
 +            }
 +
 +            log = log.getParent();
 +        }
 +
 +        return null;
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/b08492a5/modules/core/src/main/java/org/apache/ignite/marshaller/Marshaller.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/marshaller/Marshaller.java
index 14dd433,0000000..e2956dd
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/marshaller/Marshaller.java
+++ b/modules/core/src/main/java/org/apache/ignite/marshaller/Marshaller.java
@@@ -1,109 -1,0 +1,109 @@@
 +/*
 + * 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.ignite.marshaller;
 +
 +import org.apache.ignite.*;
 +import org.jetbrains.annotations.*;
 +
 +import java.io.*;
 +
 +/**
 + * {@code GridMarshaller} allows to marshal or unmarshal objects in grid. It provides
 + * serialization/deserialization mechanism for all instances that are sent across networks
 + * or are otherwise serialized.
 + * <p>
-  * Gridgain provides the following {@code GridMarshaller} implementations:
++ * Ignite provides the following {@code GridMarshaller} implementations:
 + * <ul>
 + * <li>{@link org.apache.ignite.marshaller.optimized.OptimizedMarshaller} - default</li>
 + * <li>{@link org.apache.ignite.marshaller.jdk.JdkMarshaller}</li>
 + * </ul>
 + * <p>
 + * Below are examples of marshaller configuration, usage, and injection into tasks, jobs,
 + * and SPI's.
 + * <h2 class="header">Java Example</h2>
 + * {@code GridMarshaller} can be explicitely configured in code.
 + * <pre name="code" class="java">
 + * GridJdkMarshaller marshaller = new GridJdkMarshaller();
 + *
 + * GridConfiguration cfg = new GridConfiguration();
 + *
 + * // Override marshaller.
 + * cfg.setMarshaller(marshaller);
 + *
 + * // Starts grid.
 + * G.start(cfg);
 + * </pre>
 + * <h2 class="header">Spring Example</h2>
 + * GridMarshaller can be configured from Spring XML configuration file:
 + * <pre name="code" class="xml">
-  * &lt;bean id="grid.custom.cfg" class="org.gridgain.grid.GridConfiguration" singleton="true"&gt;
++ * &lt;bean id="grid.custom.cfg" class="org.apache.ignite.configuration.IgniteConfiguration" singleton="true"&gt;
 + *     ...
 + *     &lt;property name="marshaller"&gt;
 + *         &lt;bean class="org.apache.ignite.marshaller.jdk.GridJdkMarshaller"/&gt;
 + *     &lt;/property&gt;
 + *     ...
 + * &lt;/bean&gt;
 + * </pre>
 + * <p>
 + * <img src="http://www.gridgain.com/images/spring-small.png">
 + * <br>
 + * For information about Spring framework visit <a href="http://www.springframework.org/">www.springframework.org</a>
 + */
 +public interface Marshaller {
 +    /**
 +     * Marshals object to the output stream. This method should not close
 +     * given output stream.
 +     *
 +     * @param obj Object to marshal.
 +     * @param out Output stream to marshal into.
 +     * @throws IgniteCheckedException If marshalling failed.
 +     */
 +    public void marshal(@Nullable Object obj, OutputStream out) throws IgniteCheckedException;
 +
 +    /**
 +     * Marshals object to byte array.
 +     *
 +     * @param obj Object to marshal.
 +     * @return Byte array.
 +     * @throws IgniteCheckedException If marshalling failed.
 +     */
 +    public byte[] marshal(@Nullable Object obj) throws IgniteCheckedException;
 +
 +    /**
 +     * Unmarshals object from the output stream using given class loader.
 +     * This method should not close given input stream.
 +     *
 +     * @param <T> Type of unmarshalled object.
 +     * @param in Input stream.
 +     * @param clsLdr Class loader to use.
 +     * @return Unmarshalled object.
 +     * @throws IgniteCheckedException If unmarshalling failed.
 +     */
 +    public <T> T unmarshal(InputStream in, @Nullable ClassLoader clsLdr) throws IgniteCheckedException;
 +
 +    /**
 +     * Unmarshals object from byte array using given class loader.
 +     *
 +     * @param <T> Type of unmarshalled object.
 +     * @param arr Byte array.
 +     * @param clsLdr Class loader to use.
 +     * @return Unmarshalled object.
 +     * @throws IgniteCheckedException If unmarshalling failed.
 +     */
 +    public <T> T unmarshal(byte[] arr, @Nullable ClassLoader clsLdr) throws IgniteCheckedException;
 +}


Mime
View raw message