java.sql.SQLFeatureNotSupportedException Java Examples

@Override
public boolean ownUpdatesAreVisible(int type) throws SQLException {
  throwIfClosed();
  try {
    return super.ownUpdatesAreVisible(type);
  }
  catch (RuntimeException e) {
    if ("todo: implement this method".equals(e.getMessage())) {
      throw new SQLFeatureNotSupportedException(
          "ownUpdatesAreVisible(int) is not supported", e);
    }
    else {
      throw new SQLException(e.getMessage(), e);
    }
  }
}
 

/**
 * Test Autogenerated key.
 *
 * @throws Throwable if any error occurs
 */
@Test
public void testAutogenerateKey() throws Throwable
{
  try (Connection connection = getConnection())
  {
    Statement statement = connection.createStatement();
    statement.execute("create or replace table t(c1 int)");
    statement.execute("insert into t values(1)", Statement.NO_GENERATED_KEYS);
    try
    {
      statement.execute("insert into t values(2)", Statement.RETURN_GENERATED_KEYS);
      fail("no autogenerate key is supported");
    }
    catch (SQLFeatureNotSupportedException ex)
    {
      // nop
    }
    // empty result
    ResultSet rset = statement.getGeneratedKeys();
    assertFalse(rset.next());
    rset.close();
  }
}
 

/**
 * Get expression that may be used to evaluate the tenant ID of a given row in a
 * multi-tenant table. Both the SYSTEM.CATALOG table and the SYSTEM.SEQUENCE
 * table are considered multi-tenant.
 * @param conn open Phoenix connection
 * @param fullTableName full table name
 * @return An expression that may be evaluated for a row in the provided table or
 * null if the table is not a multi-tenant table. 
 * @throws SQLException if the table name is not found, a TableNotFoundException
 * is thrown. If a multi-tenant local index is supplied a SQLFeatureNotSupportedException
 * is thrown.
 */
public static Expression getTenantIdExpression(Connection conn, String fullTableName) throws SQLException {
    PTable table = getTable(conn, fullTableName);
    // TODO: consider setting MULTI_TENANT = true for SYSTEM.CATALOG and SYSTEM.SEQUENCE
    if (!SchemaUtil.isMetaTable(table) && !SchemaUtil.isSequenceTable(table) && !table.isMultiTenant()) {
        return null;
    }
    if (table.getIndexType() == IndexType.LOCAL) {
        /*
         * With some hackery, we could deduce the tenant ID from a multi-tenant local index,
         * however it's not clear that we'd want to maintain the same prefixing of the region
         * start key, as the region boundaries may end up being different on a cluster being
         * replicated/backed-up to (which is the use case driving the method).
         */
        throw new SQLFeatureNotSupportedException();
    }
    
    int pkPosition = table.getBucketNum() == null ? 0 : 1;
    List<PColumn> pkColumns = table.getPKColumns();
    return new RowKeyColumnExpression(pkColumns.get(pkPosition), new RowKeyValueAccessor(pkColumns, pkPosition));
}
 

@Test
public void testupdateNClob70() {
  try {
    rs.updateNClob(1, (java.sql.NClob) null);
  } catch (SQLFeatureNotSupportedException sqle) {
    Assert.fail();
  } catch (SQLException sqlee) {
    // eat
  }
}
 

public void testUpdateNClobStringNotImplemented()
    throws SQLException {
    try {
        rs.updateNClob("some-column-name", (NClob)null);
        fail("ResultSet.updateNClob(String, NClob) " +
             "should not be implemented");
    } catch (SQLFeatureNotSupportedException sfnse) {
        // We are fine, do nothing.
    }
}
 

@Override
public boolean previous() throws SQLException
{
  logger.debug("public boolean previous()");

  throw new SQLFeatureNotSupportedException();
}
 

/**
 * Create SQLFeatureNotSupportedException with message, SQLState, errorCode, and Throwable
 */
@Test
public void test5() {
    SQLFeatureNotSupportedException ex =
            new SQLFeatureNotSupportedException(reason, state, errorCode, t);
    assertTrue(ex.getMessage().equals(reason)
            && ex.getSQLState().equals(state)
            && cause.equals(ex.getCause().toString())
            && ex.getErrorCode() == errorCode);
}
 

public void testUpdateNClobStringLengthlessNotImplemented()
    throws SQLException {
    try {
        rs.updateNClob("some-column-name", (Reader)null);
        fail("ResultSet.updateNClob(String, Reader) " +
             "should not be implemented");
    } catch (SQLFeatureNotSupportedException sfnse) {
        // We are fine, do nothing.
    }
}
 

@Override
protected DataAccessException doTranslate(String task, String sql, SQLException ex) {
	if (ex instanceof SQLTransientException) {
		if (ex instanceof SQLTransientConnectionException) {
			return new TransientDataAccessResourceException(buildMessage(task, sql, ex), ex);
		}
		else if (ex instanceof SQLTransactionRollbackException) {
			return new ConcurrencyFailureException(buildMessage(task, sql, ex), ex);
		}
		else if (ex instanceof SQLTimeoutException) {
			return new QueryTimeoutException(buildMessage(task, sql, ex), ex);
		}
	}
	else if (ex instanceof SQLNonTransientException) {
		if (ex instanceof SQLNonTransientConnectionException) {
			return new DataAccessResourceFailureException(buildMessage(task, sql, ex), ex);
		}
		else if (ex instanceof SQLDataException) {
			return new DataIntegrityViolationException(buildMessage(task, sql, ex), ex);
		}
		else if (ex instanceof SQLIntegrityConstraintViolationException) {
			return new DataIntegrityViolationException(buildMessage(task, sql, ex), ex);
		}
		else if (ex instanceof SQLInvalidAuthorizationSpecException) {
			return new PermissionDeniedDataAccessException(buildMessage(task, sql, ex), ex);
		}
		else if (ex instanceof SQLSyntaxErrorException) {
			return new BadSqlGrammarException(task, sql, ex);
		}
		else if (ex instanceof SQLFeatureNotSupportedException) {
			return new InvalidDataAccessApiUsageException(buildMessage(task, sql, ex), ex);
		}
	}
	else if (ex instanceof SQLRecoverableException) {
		return new RecoverableDataAccessException(buildMessage(task, sql, ex), ex);
	}

	// Fallback to Spring's own SQL state translation...
	return null;
}
 

public void testGetNClobStringNotImplemented()
    throws SQLException {
    try {
        rs.getNClob("some-column-name");
        fail("ResultSet.getNClob(String) " +
             "should not be implemented");
    } catch (SQLFeatureNotSupportedException sfnse) {
        // We are fine, do nothing.
    }
}
 

@Test
public void testupdateAsciiStream33() {
  try {
    rs.updateAsciiStream("a", null);
  } catch (SQLFeatureNotSupportedException sqle) {
    Assert.fail();
  } catch (SQLException sqlee) {
    // eat
  }
}
 

@Override
@Deprecated
public void setUnicodeStream(int parameterIndex, InputStream x, int length)
throws SQLException
{
  throw new SQLFeatureNotSupportedException();
}
 

@Override
public void updateRowId(int columnIndex, RowId x) throws SQLException
{
  logger.debug(
      "public void updateRowId(int columnIndex, RowId x)");

  throw new SQLFeatureNotSupportedException();
}
 

/**
 * Create SQLFeatureNotSupportedException with message, SQLState, and Throwable
 */
@Test
public void test6() {
    SQLFeatureNotSupportedException ex =
            new SQLFeatureNotSupportedException(reason, state, t);
    assertTrue(ex.getMessage().equals(reason)
            && ex.getSQLState().equals(state)
            && cause.equals(ex.getCause().toString())
            && ex.getErrorCode() == 0);
}
 

@Test
public void idsQueryMultipleId() throws SqlParseException, SQLFeatureNotSupportedException {
    String query = String.format("select * from %s/dog where _id = IDS_QUERY(dog,1,2,3)",TEST_INDEX_DOG);
    SearchHit[] hits = query(query).getHits();
    Assert.assertEquals(1,hits.length);
    Map<String, Object> hitAsMap = hits[0].getSourceAsMap();
    Assert.assertEquals("rex",hitAsMap.get("dog_name"));
    Assert.assertEquals("Daenerys",hitAsMap.get("holdersName"));
    Assert.assertEquals(2, hitAsMap.get("age"));

}
 

@Test
public void twoSubQueriesTest() throws SqlParseException, SQLFeatureNotSupportedException {
    String query = String.format("select * from %s/dog where holdersName IN (select firstname from %s/account where firstname = 'Hattie') and age IN (select name.ofHisName from %s/gotCharacters where name.firstname <> 'Daenerys' and name.ofHisName IS NOT NULL) ",TEST_INDEX_DOG,TEST_INDEX_ACCOUNT,TEST_INDEX_GAME_OF_THRONES);
    SearchHit[] hits = query(query).getHits();
    Assert.assertEquals(1,hits.length);
    Map<String, Object> hitAsMap = hits[0].getSourceAsMap();
    Assert.assertEquals("snoopy",hitAsMap.get("dog_name"));
    Assert.assertEquals("Hattie",hitAsMap.get("holdersName"));
    Assert.assertEquals(4,hitAsMap.get("age"));

}
 

@Override
public void updateByte( int columnIndex, byte x ) throws SQLException {
  throwIfClosed();
  try {
    super.updateByte( columnIndex, x );
  }
  catch (UnsupportedOperationException e) {
    throw new SQLFeatureNotSupportedException(e.getMessage(), e);
  }
}
 

@Override
public final void setNClob(final int parameterIndex, final NClob x) throws SQLException {
    throw new SQLFeatureNotSupportedException("setNClob");
}
 

@Override
public <T> T unwrap(Class<T> tClass) throws SQLException {
    throw new SQLFeatureNotSupportedException("Functionality is not supported");  
}
 

public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException {
	return getWrappedDataSource().getParentLogger();
}
 

@Test(expected = SQLFeatureNotSupportedException.class)
public void assertSetNetworkTimeout() throws SQLException {
    for (ShardingSphereConnection each : shardingSphereConnections) {
        each.setNetworkTimeout(null, 0);
    }
}
 

@Test(dataProvider = "rowSetType",
        expectedExceptions = SQLFeatureNotSupportedException.class)
public void commonRowSetTest0119(RowSet rs) throws Exception {
    Reader rdr = null;
    rs.setClob("one", rdr, query.length());
}
 

@Test
public void joinWithAllAliasOnReturnNL() throws SQLFeatureNotSupportedException, IOException, SqlParseException {
    joinWithAllAliasOnReturn(true);
}
 

/** {@inheritDoc} */
@Override public void setLogWriter(PrintWriter out) throws SQLException {
    throw new SQLFeatureNotSupportedException();
}
 

@Override
public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
	throw new SQLFeatureNotSupportedException();
}
 

@Override
public final void closeOnCompletion() throws SQLException {
    throw new SQLFeatureNotSupportedException("closeOnCompletion");
}
 

@Override
public boolean absolute(int row) throws SQLException {
    throw new SQLFeatureNotSupportedException();
}
 

@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
    return delegate.getParentLogger();
}
 

@Override
public void updateBoolean(int columnIndex, boolean x) throws SQLException {
	throw new SQLFeatureNotSupportedException();
}
 

@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
	return delegate.getParentLogger();
}