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; }
