Java BadSqlGrammarException类代码示例

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
private OAuth2AccessToken readAccessTokenFromSecureStore(String tokenKey) {
    if (tokenKey.length() > TOKEN_KEY_MAX_LENGTH) {
        throw new IllegalArgumentException(Messages.TOKEN_KEY_FORMAT_NOT_VALID);
    }

    SqlParameter storeNameParam = new SqlParameter(Types.VARCHAR);
    SqlParameter forXsApplicationUserParam = new SqlParameter(Types.BOOLEAN);
    SqlParameter keyParam = new SqlParameter(Types.VARCHAR);
    SqlOutParameter valueParam = new SqlOutParameter("VALUE", Types.VARBINARY);

    List<SqlParameter> paramList = Arrays.asList(storeNameParam, forXsApplicationUserParam, keyParam, valueParam);
    Map<String, Object> result = null;
    try {
        result = callRetrieve(tokenKey, paramList, PROCEDURE_SECURESTORE_RETRIEVE);
    } catch (BadSqlGrammarException e) {
        throwIfShouldNotIgnore(e, RETRIEVE_PROCEDURE_NAME);
        result = callRetrieve(tokenKey, paramList, PROCEDURE_SECURESTORE_RETRIEVE_LEGACY);
    }
    byte[] tokenBytes = (byte[]) result.get("VALUE");
    if (tokenBytes == null) {
        throw new IllegalArgumentException(Messages.TOKEN_NOT_FOUND_IN_SECURE_STORE);
    }
    byte[] decompressedBytes = CompressUtil.decompress(tokenBytes);
    OAuth2AccessToken accessToken = TokenUtil.createToken(new String(decompressedBytes, StandardCharsets.UTF_8));
    return accessToken;
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Override
protected DataAccessException doTranslate(String task, String sql, SQLException ex) {
	String sqlState = getSqlState(ex);
	if (sqlState != null && sqlState.length() >= 2) {
		String classCode = sqlState.substring(0, 2);
		if (logger.isDebugEnabled()) {
			logger.debug("Extracted SQL state class '" + classCode + "' from value '" + sqlState + "'");
		}
		if (BAD_SQL_GRAMMAR_CODES.contains(classCode)) {
			return new BadSqlGrammarException(task, sql, ex);
		}
		else if (DATA_INTEGRITY_VIOLATION_CODES.contains(classCode)) {
			return new DataIntegrityViolationException(buildMessage(task, sql, ex), ex);
		}
		else if (DATA_ACCESS_RESOURCE_FAILURE_CODES.contains(classCode)) {
			return new DataAccessResourceFailureException(buildMessage(task, sql, ex), ex);
		}
		else if (TRANSIENT_DATA_ACCESS_RESOURCE_CODES.contains(classCode)) {
			return new TransientDataAccessResourceException(buildMessage(task, sql, ex), ex);
		}
		else if (CONCURRENCY_FAILURE_CODES.contains(classCode)) {
			return new ConcurrencyFailureException(buildMessage(task, sql, ex), ex);
		}
	}
	return null;
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@ResponseBody
@Order(Ordered.HIGHEST_PRECEDENCE)
@ExceptionHandler(Throwable.class)
public final ResponseEntity<Result<String>> handleUncaughtException(final Throwable exception, final WebRequest
        request) {
    // adds information about encountered error to application log
    LOG.error(MessageHelper.getMessage("logger.error", request.getDescription(true)), exception);
    HttpStatus code = HttpStatus.OK;

    String message;
    if (exception instanceof FileNotFoundException) {
        // any details about real path of a resource should be normally prevented to send to the client
        message = MessageHelper.getMessage("error.io.not.found");
    } else if (exception instanceof DataAccessException) {
        // any details about data access error should be normally prevented to send to the client,
        // as its message can contain information about failed SQL query or/and database schema
        if (exception instanceof BadSqlGrammarException) {
            // for convenience we need to provide detailed information about occurred BadSqlGrammarException,
            // but it can be retrieved
            SQLException root = ((BadSqlGrammarException) exception).getSQLException();
            if (root.getNextException() != null) {
                LOG.error(MessageHelper.getMessage("logger.error.root.cause", request.getDescription(true)),
                    root.getNextException());
            }
            message = MessageHelper.getMessage("error.sql.bad.grammar");
        } else {
            message = MessageHelper.getMessage("error.sql");
        }
    } else if (exception instanceof UnauthorizedClientException) {
        message = exception.getMessage();
        code = HttpStatus.UNAUTHORIZED;
    } else {
        message = exception.getMessage();
    }

    return new ResponseEntity<>(Result.error(StringUtils.defaultString(StringUtils.trimToNull(message),
                                   MessageHelper.getMessage("error" + ".default"))), code);
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Test
@SuppressWarnings("resource")
public void customErrorCodeTranslation() {
	new ClassPathXmlApplicationContext("test-custom-translators-context.xml",
			CustomSQLExceptionTranslatorRegistrarTests.class);

	SQLErrorCodes codes = SQLErrorCodesFactory.getInstance().getErrorCodes("H2");
	SQLErrorCodeSQLExceptionTranslator sext = new SQLErrorCodeSQLExceptionTranslator();
	sext.setSqlErrorCodes(codes);

	DataAccessException exFor4200 = sext.doTranslate("", "", new SQLException("Ouch", "42000", 42000));
	assertNotNull("Should have been translated", exFor4200);
	assertTrue("Should have been instance of BadSqlGrammarException",
		BadSqlGrammarException.class.isAssignableFrom(exFor4200.getClass()));

	DataAccessException exFor2 = sext.doTranslate("", "", new SQLException("Ouch", "42000", 2));
	assertNotNull("Should have been translated", exFor2);
	assertTrue("Should have been instance of TransientDataAccessResourceException",
		TransientDataAccessResourceException.class.isAssignableFrom(exFor2.getClass()));

	DataAccessException exFor3 = sext.doTranslate("", "", new SQLException("Ouch", "42000", 3));
	assertNull("Should not have been translated", exFor3);
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Test
public void testSQLErrorCodeTranslation() throws Exception {
	final SQLException sqlException = new SQLException("I have a known problem", "99999", 1054);
	final String sql = "SELECT ID FROM CUSTOMER";

	given(this.resultSet.next()).willReturn(true);
	mockDatabaseMetaData(false);
	given(this.connection.createStatement()).willReturn(this.preparedStatement);

	this.thrown.expect(BadSqlGrammarException.class);
	this.thrown.expect(exceptionCause(sameInstance(sqlException)));
	try {
		this.template.query(sql, new RowCallbackHandler() {
			@Override
			public void processRow(ResultSet rs) throws SQLException {
				throw sqlException;
			}
		});
		fail("Should have thrown BadSqlGrammarException");
	}
	finally {
		verify(this.resultSet).close();
		verify(this.preparedStatement).close();
		verify(this.connection, atLeastOnce()).close();
	}
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Test
public void testNoSuchStoredProcedure() throws Exception {
	final String NO_SUCH_PROC = "x";
	SQLException sqlException = new SQLException("Syntax error or access violation exception", "42000");
	given(databaseMetaData.getDatabaseProductName()).willReturn("MyDB");
	given(databaseMetaData.getDatabaseProductName()).willReturn("MyDB");
	given(databaseMetaData.getUserName()).willReturn("me");
	given(databaseMetaData.storesLowerCaseIdentifiers()).willReturn(true);
	given(callableStatement.execute()).willThrow(sqlException);
	given(connection.prepareCall("{call " + NO_SUCH_PROC + "()}")).willReturn(callableStatement);
	SimpleJdbcCall sproc = new SimpleJdbcCall(dataSource).withProcedureName(NO_SUCH_PROC);
	thrown.expect(BadSqlGrammarException.class);
	thrown.expect(exceptionCause(sameInstance(sqlException)));
	try {
		sproc.execute();
	}
	finally {
		verify(callableStatement).close();
		verify(connection, atLeastOnce()).close();
	}
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Override
public void loadData() {
	String sql = "select * from " + tableName;
	List<DynamicEnumRecord> list;
	try {
		list = jdbc.queryForList(sql, DynamicEnumRecord.class);
	}
	catch (BadSqlGrammarException e) {
		return;
	}
	logger.info("loadData list:" + list);

	data.clear();
	for (DynamicEnumRecord record : list) {
		String enumId = record.getEnumId();
		data.put(enumId, record);
	}
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
public ModelVersion get(String modelName) {
    Object o = null;

    SelectStatementCreator sel = new SelectStatementCreator();
    sel.setValues(modelName);
    try {
        o = jdbc.query(sel, extractor);
    } catch (BadSqlGrammarException ex) {
        try {
            // try simples query possible to see if table exists
            jdbc.queryForInt("SELECT count(*) FROM " + tableName);

            // some other kind of error
            throw ex;
        } catch (BadSqlGrammarException ex2) {
            log.debug("previous install not found: " + ex2.getMessage());
            o = null;
        }
    }
    if (o == null) {
        ModelVersion mv = new ModelVersion(modelName);
        log.debug("created: " + mv);
        return mv;
    }
    return (ModelVersion) o;
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Test
public void testInitializationDisabled() throws Exception {
	this.context.register(DataSourceAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();
	DataSource dataSource = this.context.getBean(DataSource.class);
	this.context.publishEvent(new DataSourceInitializedEvent(dataSource));
	assertThat(dataSource instanceof org.apache.tomcat.jdbc.pool.DataSource).isTrue();
	assertThat(dataSource).isNotNull();
	JdbcOperations template = new JdbcTemplate(dataSource);
	try {
		template.queryForObject("SELECT COUNT(*) from BAR", Integer.class);
		fail("Query should have failed as BAR table does not exist");
	}
	catch (BadSqlGrammarException ex) {
		SQLException sqlException = ex.getSQLException();
		int expectedCode = -5501; // user lacks privilege or object not found
		assertThat(sqlException.getErrorCode()).isEqualTo(expectedCode);
	}
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Test
public void testInitializationDisabled() throws Exception {
	this.context.register(DataSourceAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();

	DataSource dataSource = this.context.getBean(DataSource.class);

	this.context.publishEvent(new DataSourceInitializedEvent(dataSource));

	assertThat(dataSource instanceof org.apache.tomcat.jdbc.pool.DataSource).isTrue();
	assertThat(dataSource).isNotNull();
	JdbcOperations template = new JdbcTemplate(dataSource);

	try {
		template.queryForObject("SELECT COUNT(*) from BAR", Integer.class);
		fail("Query should have failed as BAR table does not exist");
	}
	catch (BadSqlGrammarException ex) {
		SQLException sqlException = ex.getSQLException();
		int expectedCode = -5501; // user lacks privilege or object not found
		assertThat(sqlException.getErrorCode()).isEqualTo(expectedCode);
	}
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Override
public String createViewTable( SqlView sqlView )
{
    dropViewTable( sqlView );

    final String sql = TYPE_CREATE_PREFIX_MAP.get( sqlView.getType() ) + statementBuilder.columnQuote( sqlView.getViewName() ) + " AS " + sqlView.getSqlQuery();

    log.debug( "Create view SQL: " + sql );

    try
    {
        jdbcTemplate.execute( sql );

        return null;
    }
    catch ( BadSqlGrammarException ex )
    {
        return ex.getCause().getMessage();
    }
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Override
public long getEventCount( EventQueryParams params )
{
    String sql = "select count(psi) ";
    
    sql += getFromWhereClause( params );
    
    long count = 0;
    
    try
    {
        log.debug( "Analytics event count SQL: " + sql );
        
        count = jdbcTemplate.queryForObject( sql, Long.class );
    }
    catch ( BadSqlGrammarException ex )
    {
        log.info( QUERY_ERR_MSG, ex );
    }
    
    return count;
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Test
public void test_update_rollback() {
  DbLegalEntityBeanMaster w = new DbLegalEntityBeanMaster(_lenMaster.getDbConnector());
  w.setElSqlBundle(ElSqlBundle.of(new ElSqlConfig("TestRollback"), DbBeanMaster.class));
  final LegalEntityDocument base = _lenMaster.get(UniqueId.of("DbLen", "101", "0"));
  UniqueId uniqueId = UniqueId.of("DbLen", "101", "0");
  ManageableLegalEntity legalEntity = new MockLegalEntity("TestLegalEntity", ExternalIdBundle.of("A", "B"), Currency.GBP);
  legalEntity.setUniqueId(uniqueId);
  LegalEntityDocument input = new LegalEntityDocument(legalEntity);
  try {
    w.update(input);
    Assert.fail();
  } catch (BadSqlGrammarException ex) {
    // expected
  }
  final LegalEntityDocument test = _lenMaster.get(UniqueId.of("DbLen", "101", "0"));

  assertEquals(base, test);
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Test
public void test_update_rollback() {
  DbPositionMaster w = new DbPositionMaster(_posMaster.getDbConnector());
  w.setElSqlBundle(ElSqlBundle.of(new ElSqlConfig("TestRollback"), DbPositionMaster.class));
  final PositionDocument base = _posMaster.get(UniqueId.of("DbPos", "121", "0"));
  ManageablePosition pos = new ManageablePosition(BigDecimal.TEN, ExternalId.of("A", "B"));
  pos.setUniqueId(UniqueId.of("DbPos", "121", "0"));
  PositionDocument input = new PositionDocument(pos);
  try {
    w.update(input);
    Assert.fail();
  } catch (BadSqlGrammarException ex) {
    // expected
  }
  final PositionDocument test = _posMaster.get(UniqueId.of("DbPos", "121", "0"));
  
  assertEquals(base, test);
}
 

import org.springframework.jdbc.BadSqlGrammarException; //导入依赖的package包/类
@Test
public void test_update_rollback() {
  DbSecurityMaster w = new DbSecurityMaster(_secMaster.getDbConnector());
  w.setElSqlBundle(ElSqlBundle.of(new ElSqlConfig("TestRollback"), DbSecurityMaster.class));
  final SecurityDocument base = _secMaster.get(UniqueId.of("DbSec", "101", "0"));
  UniqueId uniqueId = UniqueId.of("DbSec", "101", "0");
  ManageableSecurity security = new ManageableSecurity(uniqueId, "Name", "Type", ExternalIdBundle.of("A", "B"));
  SecurityDocument input = new SecurityDocument(security);
  try {
    w.update(input);
    Assert.fail();
  } catch (BadSqlGrammarException ex) {
    // expected
  }
  final SecurityDocument test = _secMaster.get(UniqueId.of("DbSec", "101", "0"));
  
  assertEquals(base, test);
}