ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From agoncha...@apache.org
Subject [12/50] [abbrv] incubator-ignite git commit: Merge branch 'sprint-1' into ignite-128
Date Wed, 11 Feb 2015 03:02:38 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/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 0000000,9d7adcf..ba09e1d
mode 000000,100644..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,0 -1,1519 +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.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 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/0a1b1b7a/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 0000000,3ef60af..6637bf5
mode 000000,100644..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,0 -1,448 +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.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 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/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/processors/portable/GridPortableProcessor.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/portable/GridPortableProcessor.java
index 02100f2,8dc3fa9..291caa0
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/portable/GridPortableProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/portable/GridPortableProcessor.java
@@@ -17,9 -17,10 +17,10 @@@
  
  package org.apache.ignite.internal.processors.portable;
  
+ import org.apache.ignite.*;
 -import org.apache.ignite.client.marshaller.*;
+ import org.apache.ignite.cluster.*;
 +import org.apache.ignite.internal.client.marshaller.*;
  import org.apache.ignite.internal.processors.*;
- import org.apache.ignite.portables.*;
  import org.jetbrains.annotations.*;
  
  import java.nio.*;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/processors/portable/os/GridOsPortableProcessor.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/portable/os/GridOsPortableProcessor.java
index 718231f,2442eb2..1ac3077
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/portable/os/GridOsPortableProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/portable/os/GridOsPortableProcessor.java
@@@ -17,11 -17,12 +17,12 @@@
  
  package org.apache.ignite.internal.processors.portable.os;
  
+ import org.apache.ignite.*;
 -import org.apache.ignite.client.marshaller.*;
+ import org.apache.ignite.cluster.*;
  import org.apache.ignite.internal.*;
 +import org.apache.ignite.internal.client.marshaller.*;
  import org.apache.ignite.internal.processors.*;
  import org.apache.ignite.internal.processors.portable.*;
- import org.apache.ignite.portables.*;
  import org.jetbrains.annotations.*;
  
  import java.nio.*;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/GridRestProcessor.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/rest/GridRestProcessor.java
index 53953b7,3a529f5..b40f303
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/GridRestProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/GridRestProcessor.java
@@@ -26,7 -26,8 +26,7 @@@ import org.apache.ignite.internal.proce
  import org.apache.ignite.internal.processors.rest.client.message.*;
  import org.apache.ignite.internal.processors.rest.handlers.*;
  import org.apache.ignite.internal.processors.rest.handlers.cache.*;
- import org.apache.ignite.internal.processors.rest.handlers.metadata.*;
+ import org.apache.ignite.internal.processors.rest.handlers.datastructures.*;
 -import org.apache.ignite.internal.processors.rest.handlers.log.*;
  import org.apache.ignite.internal.processors.rest.handlers.task.*;
  import org.apache.ignite.internal.processors.rest.handlers.top.*;
  import org.apache.ignite.internal.processors.rest.handlers.version.*;
@@@ -252,7 -253,8 +252,7 @@@ public class GridRestProcessor extends 
              addHandler(new GridTaskCommandHandler(ctx));
              addHandler(new GridTopologyCommandHandler(ctx));
              addHandler(new GridVersionCommandHandler(ctx));
-             addHandler(new GridPortableMetadataHandler(ctx));
 -            addHandler(new GridLogCommandHandler(ctx));
+             addHandler(new DataStructuresCommandHandler(ctx));
  
              // Start protocols.
              startTcpProtocol();

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

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/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/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/protocols/tcp/GridTcpRestProtocol.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/rest/protocols/tcp/GridTcpRestProtocol.java
index ecc681d,7482a79..771e27f
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/protocols/tcp/GridTcpRestProtocol.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/protocols/tcp/GridTcpRestProtocol.java
@@@ -259,18 -205,18 +205,18 @@@ public class GridTcpRestProtocol extend
       *      server was unable to start.
       */
      private boolean startTcpServer(InetAddress hostAddr, int port, GridNioServerListener<GridClientMessage> lsnr,
 -        GridNioParser parser, @Nullable SSLContext sslCtx, ClientConnectionConfiguration cfg) {
 +        GridNioParser parser, @Nullable SSLContext sslCtx, ConnectorConfiguration cfg) {
          try {
-             GridNioFilter codec = new GridNioCodecFilter(parser, log, true);
+             GridNioFilter codec = new GridNioCodecFilter(parser, log, false);
  
              GridNioFilter[] filters;
  
              if (sslCtx != null) {
                  GridNioSslFilter sslFilter = new GridNioSslFilter(sslCtx, log);
  
-                 sslFilter.directMode(true);
+                 sslFilter.directMode(false);
  
 -                boolean auth = cfg.isRestTcpSslClientAuth();
 +                boolean auth = cfg.isSslClientAuth();
  
                  sslFilter.wantClientAuth(auth);
  
@@@ -289,20 -235,19 +235,19 @@@
                  .port(port)
                  .listener(lsnr)
                  .logger(log)
 -                .selectorCount(cfg.getRestTcpSelectorCount())
 +                .selectorCount(cfg.getSelectorCount())
                  .gridName(ctx.gridName())
 -                .tcpNoDelay(cfg.isRestTcpNoDelay())
 -                .directBuffer(cfg.isRestTcpDirectBuffer())
 +                .tcpNoDelay(cfg.isNoDelay())
 +                .directBuffer(cfg.isDirectBuffer())
                  .byteOrder(ByteOrder.nativeOrder())
 -                .socketSendBufferSize(cfg.getRestTcpSendBufferSize())
 -                .socketReceiveBufferSize(cfg.getRestTcpReceiveBufferSize())
 -                .sendQueueLimit(cfg.getRestTcpSendQueueLimit())
 +                .socketSendBufferSize(cfg.getSendBufferSize())
 +                .socketReceiveBufferSize(cfg.getReceiveBufferSize())
 +                .sendQueueLimit(cfg.getSendQueueLimit())
                  .filters(filters)
-                 .directMode(true)
-                 .messageWriter(msgWriter)
+                 .directMode(false)
                  .build();
  
 -            srv.idleTimeout(cfg.getRestIdleTimeout());
 +            srv.idleTimeout(cfg.getIdleTimeout());
  
              srv.start();
  

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/util/nio/GridNioServer.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/visor/node/VisorExecutorServiceConfiguration.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/visor/node/VisorExecutorServiceConfiguration.java
index cf5185d,6aefb13..6f987c9
--- a/modules/core/src/main/java/org/apache/ignite/internal/visor/node/VisorExecutorServiceConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/node/VisorExecutorServiceConfiguration.java
@@@ -62,21 -48,16 +48,16 @@@ public class VisorExecutorServiceConfig
      public static VisorExecutorServiceConfiguration from(IgniteConfiguration c) {
          VisorExecutorServiceConfiguration cfg = new VisorExecutorServiceConfiguration();
  
-         cfg.executeService(compactClass(c.getExecutorService()));
-         cfg.executeServiceShutdown(c.getExecutorServiceShutdown());
+         cfg.executeService(c.getPublicThreadPoolSize());
  
-         cfg.systemExecutorService(compactClass(c.getSystemExecutorService()));
-         cfg.systemExecutorServiceShutdown(c.getSystemExecutorServiceShutdown());
+         cfg.systemExecutorService(c.getSystemThreadPoolSize());
  
-         cfg.p2pExecutorService(compactClass(c.getPeerClassLoadingExecutorService()));
-         cfg.p2pExecutorServiceShutdown(c.getSystemExecutorServiceShutdown());
+         cfg.p2pExecutorService(c.getPeerClassLoadingThreadPoolSize());
  
 -        ClientConnectionConfiguration cc = c.getClientConnectionConfiguration();
 +        ConnectorConfiguration cc = c.getConnectorConfiguration();
  
-         if (cc != null) {
-             cfg.restExecutorService(compactClass(cc.getExecutorService()));
-             cfg.restExecutorServiceShutdown(cc.isExecutorServiceShutdown());
-         }
+         if (cc != null)
 -            cfg.restExecutorService(cc.getRestThreadPoolSize());
++            cfg.restExecutorService(cc.getThreadPoolSize());
  
          return cfg;
      }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/startup/BasicWarmupClosure.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/default-spring-url-testing.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/example-cache.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/io-manager-benchmark.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/job-loadtest/client.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/job-loadtest/server.xml
----------------------------------------------------------------------
diff --cc modules/core/src/test/config/job-loadtest/server.xml
index fafd612,2af22e1..da548e5
--- a/modules/core/src/test/config/job-loadtest/server.xml
+++ b/modules/core/src/test/config/job-loadtest/server.xml
@@@ -35,22 -36,9 +36,11 @@@
  
          <property name="localHost" value="127.0.0.1"/>
  
 +        <property name="connectorConfiguration"><null/></property>
 +
          <property name="deploymentMode" value="CONTINUOUS"/>
  
-         <property name="executorService">
-             <bean class="org.apache.ignite.thread.IgniteThreadPoolExecutor">
-                 <constructor-arg type="int" value="300"/>
-                 <constructor-arg type="int" value="300"/>
-                 <constructor-arg type="long">
-                     <util:constant static-field="java.lang.Long.MAX_VALUE"/>
-                 </constructor-arg>
-                 <constructor-arg type="java.util.concurrent.BlockingQueue">
-                     <bean class="java.util.concurrent.LinkedBlockingQueue"/>
-                 </constructor-arg>
-             </bean>
-         </property>
+         <property name="publicThreadPoolSize" value="300"/>
  
          <property name="failoverSpi">
              <bean class="org.apache.ignite.spi.failover.jobstealing.JobStealingFailoverSpi">

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/jobs-load-base.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/load/cache-benchmark.xml
----------------------------------------------------------------------
diff --cc modules/core/src/test/config/load/cache-benchmark.xml
index 80d4254,3f67dfd..5aa5e58
--- a/modules/core/src/test/config/load/cache-benchmark.xml
+++ b/modules/core/src/test/config/load/cache-benchmark.xml
@@@ -60,13 -60,11 +60,13 @@@
              </list>
          </property>
  
 +        <property name="connectorConfiguration"><null/></property>
 +
          <property name="includeEventTypes">
              <list>
-                 <util:constant static-field="org.apache.ignite.events.IgniteEventType.EVT_TASK_FAILED"/>
-                 <util:constant static-field="org.apache.ignite.events.IgniteEventType.EVT_TASK_FINISHED"/>
-                 <util:constant static-field="org.apache.ignite.events.IgniteEventType.EVT_JOB_MAPPED"/>
+                 <util:constant static-field="org.apache.ignite.events.EventType.EVT_TASK_FAILED"/>
+                 <util:constant static-field="org.apache.ignite.events.EventType.EVT_TASK_FINISHED"/>
+                 <util:constant static-field="org.apache.ignite.events.EventType.EVT_JOB_MAPPED"/>
              </list>
          </property>
          <property name="includeProperties"><list/></property>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/load/cache-client-benchmark.xml
----------------------------------------------------------------------
diff --cc modules/core/src/test/config/load/cache-client-benchmark.xml
index 39bc2a9,3d367e4..03685e8
--- a/modules/core/src/test/config/load/cache-client-benchmark.xml
+++ b/modules/core/src/test/config/load/cache-client-benchmark.xml
@@@ -60,13 -60,11 +60,13 @@@
              </list>
          </property>
  
 +        <property name="connectorConfiguration"><null/></property>
 +
          <property name="includeEventTypes">
              <list>
-                 <util:constant static-field="org.apache.ignite.events.IgniteEventType.EVT_TASK_FAILED"/>
-                 <util:constant static-field="org.apache.ignite.events.IgniteEventType.EVT_TASK_FINISHED"/>
-                 <util:constant static-field="org.apache.ignite.events.IgniteEventType.EVT_JOB_MAPPED"/>
+                 <util:constant static-field="org.apache.ignite.events.EventType.EVT_TASK_FAILED"/>
+                 <util:constant static-field="org.apache.ignite.events.EventType.EVT_TASK_FINISHED"/>
+                 <util:constant static-field="org.apache.ignite.events.EventType.EVT_JOB_MAPPED"/>
              </list>
          </property>
          <property name="includeProperties"><list/></property>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/load/dsi-load-base.xml
----------------------------------------------------------------------
diff --cc modules/core/src/test/config/load/dsi-load-base.xml
index 5f75f33,d8c1684..27c319f
--- a/modules/core/src/test/config/load/dsi-load-base.xml
+++ b/modules/core/src/test/config/load/dsi-load-base.xml
@@@ -72,35 -72,11 +72,13 @@@
  
          <property name="peerClassLoadingEnabled" value="false"/>
  
 +        <property name="connectorConfiguration"><null/></property>
 +
          <property name="deploymentMode" value="CONTINUOUS"/>
  
-         <property name="executorService">
-             <bean class="org.apache.ignite.thread.IgniteThreadPoolExecutor">
-                 <constructor-arg type="int" value="#{T(java.lang.Runtime).getRuntime().availableProcessors() * 4}"/>
-                 <constructor-arg type="int" value="#{T(java.lang.Runtime).getRuntime().availableProcessors() * 4}"/>
-                 <constructor-arg type="long">
-                     <util:constant static-field="java.lang.Long.MAX_VALUE"/>
-                 </constructor-arg>
-                 <constructor-arg type="java.util.concurrent.BlockingQueue">
-                     <bean class="java.util.concurrent.LinkedBlockingQueue"/>
-                 </constructor-arg>
-             </bean>
-         </property>
+         <property name="publicThreadPoolSize" value="#{T(java.lang.Runtime).getRuntime().availableProcessors() * 4}"/>
  
-         <property name="systemExecutorService">
-             <bean class="org.apache.ignite.thread.IgniteThreadPoolExecutor">
-                 <constructor-arg type="int" value="#{T(java.lang.Runtime).getRuntime().availableProcessors() * 8}"/>
-                 <constructor-arg type="int" value="#{T(java.lang.Runtime).getRuntime().availableProcessors() * 8}"/>
-                 <constructor-arg type="long">
-                     <util:constant static-field="java.lang.Long.MAX_VALUE"/>
-                 </constructor-arg>
-                 <constructor-arg type="java.util.concurrent.BlockingQueue">
-                     <bean class="java.util.concurrent.LinkedBlockingQueue"/>
-                 </constructor-arg>
-             </bean>
-         </property>
+         <property name="systemThreadPoolSize" value="#{T(java.lang.Runtime).getRuntime().availableProcessors() * 8}"/>
  
          <property name="failoverSpi">
              <bean class="org.apache.ignite.spi.failover.always.AlwaysFailoverSpi">

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/load/merge-sort-base.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/loaders/grid-cfg-2-grids.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/loaders/grid-cfg.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/spring-cache-put-remove-load.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/spring-start-nodes-attr.xml
----------------------------------------------------------------------
diff --cc modules/core/src/test/config/spring-start-nodes-attr.xml
index 5043ddd,422b1a4..8db8598
--- a/modules/core/src/test/config/spring-start-nodes-attr.xml
+++ b/modules/core/src/test/config/spring-start-nodes-attr.xml
@@@ -34,10 -34,8 +34,10 @@@
  
          <property name="localHost" value="127.0.0.1"/>
  
 +        <property name="connectorConfiguration"><null/></property>
 +
          <property name="marshaller">
-             <bean class="org.apache.ignite.marshaller.optimized.IgniteOptimizedMarshaller">
+             <bean class="org.apache.ignite.marshaller.optimized.OptimizedMarshaller">
                  <property name="requireSerializable" value="false"/>
              </bean>
          </property>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/spring-start-nodes.xml
----------------------------------------------------------------------
diff --cc modules/core/src/test/config/spring-start-nodes.xml
index f0001cf,93469f8..8ab68fb
--- a/modules/core/src/test/config/spring-start-nodes.xml
+++ b/modules/core/src/test/config/spring-start-nodes.xml
@@@ -28,10 -28,8 +28,10 @@@
      <bean id="grid.cfg" class="org.apache.ignite.configuration.IgniteConfiguration">
          <property name="localHost" value="127.0.0.1"/>
  
 +        <property name="connectorConfiguration"><null/></property>
 +
          <property name="marshaller">
-             <bean class="org.apache.ignite.marshaller.optimized.IgniteOptimizedMarshaller">
+             <bean class="org.apache.ignite.marshaller.optimized.OptimizedMarshaller">
                  <property name="requireSerializable" value="false"/>
              </bean>
          </property>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/streamer/spring-streamer-base.xml
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/websession/spring-cache-1.xml
----------------------------------------------------------------------
diff --cc modules/core/src/test/config/websession/spring-cache-1.xml
index a38eabe,fd0073b..2bc770a
--- a/modules/core/src/test/config/websession/spring-cache-1.xml
+++ b/modules/core/src/test/config/websession/spring-cache-1.xml
@@@ -27,11 -27,9 +27,11 @@@
  
          <property name="localHost" value="127.0.0.1"/>
  
 +        <property name="connectorConfiguration"><null/></property>
 +
          <property name="cacheConfiguration">
              <list>
-                 <bean class="org.apache.ignite.cache.CacheConfiguration">
+                 <bean class="org.apache.ignite.configuration.CacheConfiguration">
                      <property name="name" value="partitioned"/>
  
                      <property name="cacheMode" value="PARTITIONED"/>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/websession/spring-cache-2.xml
----------------------------------------------------------------------
diff --cc modules/core/src/test/config/websession/spring-cache-2.xml
index 8d63d12,bbb371e..ca9d66b
--- a/modules/core/src/test/config/websession/spring-cache-2.xml
+++ b/modules/core/src/test/config/websession/spring-cache-2.xml
@@@ -27,11 -27,9 +27,11 @@@
  
          <property name="localHost" value="127.0.0.1"/>
  
 +        <property name="connectorConfiguration"><null/></property>
 +
          <property name="cacheConfiguration">
              <list>
-                 <bean class="org.apache.ignite.cache.CacheConfiguration">
+                 <bean class="org.apache.ignite.configuration.CacheConfiguration">
                      <property name="name" value="partitioned"/>
  
                      <property name="cacheMode" value="PARTITIONED"/>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/config/websession/spring-cache-3.xml
----------------------------------------------------------------------
diff --cc modules/core/src/test/config/websession/spring-cache-3.xml
index c6db62b,293733b..8354836
--- a/modules/core/src/test/config/websession/spring-cache-3.xml
+++ b/modules/core/src/test/config/websession/spring-cache-3.xml
@@@ -27,11 -27,9 +27,11 @@@
  
          <property name="localHost" value="127.0.0.1"/>
  
 +        <property name="connectorConfiguration"><null/></property>
 +
          <property name="cacheConfiguration">
              <list>
-                 <bean class="org.apache.ignite.cache.CacheConfiguration">
+                 <bean class="org.apache.ignite.configuration.CacheConfiguration">
                      <property name="name" value="partitioned"/>
  
                      <property name="cacheMode" value="PARTITIONED"/>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/java/org/apache/ignite/internal/GridDiscoveryEventSelfTest.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/java/org/apache/ignite/internal/GridLifecycleAwareSelfTest.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/java/org/apache/ignite/internal/GridStartStopSelfTest.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheDeploymentSelfTest.java
----------------------------------------------------------------------
diff --cc modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheDeploymentSelfTest.java
index 3d99be5,f5ae736..2d40cc1
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheDeploymentSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheDeploymentSelfTest.java
@@@ -91,9 -91,7 +91,9 @@@ public class GridCacheDeploymentSelfTes
  
          cfg.setDiscoverySpi(disco);
  
 +        cfg.setConnectorConfiguration(null);
 +
-         cfg.setMarshaller(new IgniteOptimizedMarshaller(false));
+         cfg.setMarshaller(new OptimizedMarshaller(false));
  
          return cfg;
      }


Mime
View raw message