How to use

QueryExecutionKernelException

in

org.neo4j.kernel.impl.query

@Override
public Result executeQuery( String query, MapValue parameters, TransactionalContext context )
    throws QueryExecutionKernelException
{
  try
  {
    return inner.execute( query, parameters, context, false );
  }
  catch ( CypherException e )
  {
    throw new QueryExecutionKernelException( e );
  }
}

  public QueryExecutionException asUserException()
  {
    return new QueryExecutionException( getMessage(), this, status().code().serialize() );
  }
}

  private static QueryExecutionException converted( CypherException e )
  {
    return new QueryExecutionKernelException( e ).asUserException();
  }
}

@Test
public void failQueryAfterMaxRetriesReached() throws QueryExecutionKernelException
{
  when( versionContext.isDirty() ).thenReturn( true );
  try
  {
    executionEngine.executeWithRetries( "query", Collections.emptyMap(), transactionalContext, executor );
  }
  catch ( QueryExecutionKernelException e )
  {
    assertEquals( "Unable to get clean data snapshot for query 'query' after 5 attempts.", e.getMessage() );
  }
  verify( executor, times( 5 ) ).execute( any(), anyMap(), any() );
  verify( versionContext, times( 5 ) ).initRead();
}

@Override
public Result executeQuery( String query, MapValue parameters, TransactionalContext tc )
{
  try
  {
    availability.assertDatabaseAvailable();
    return sourceModule.neoStoreDataSource.getExecutionEngine().executeQuery( query, parameters, tc );
  }
  catch ( QueryExecutionKernelException e )
  {
    throw e.asUserException();
  }
}

@Test
void shouldThrowOnCommitInAutoCommit() throws Exception
{
  QueryExecutionKernelException e = assertThrows( QueryExecutionKernelException.class, () ->
      TransactionStateMachine.State.AUTO_COMMIT.commitTransaction( mutableState, stateMachineSPI ) );
  assertEquals( "No current transaction to commit.", e.getMessage() );
}

@Override
public Result executeQuery( String query, MapValue parameters, TransactionalContext transactionalContext )
{
  try
  {
    availability.assertDatabaseAvailable();
    return dataSource.neoStoreDataSource.getExecutionEngine().executeQuery( query, parameters, transactionalContext );
  }
  catch ( QueryExecutionKernelException e )
  {
    throw e.asUserException();
  }
}

@Override
public Result profileQuery( String query, MapValue parameters, TransactionalContext context )
    throws QueryExecutionKernelException
{
  try
  {
    return inner.execute( query, parameters, context, true );
  }
  catch ( CypherException e )
  {
    throw new QueryExecutionKernelException( e );
  }
}

private void checkIfDirty()
{
  if ( versionContext.isDirty() )
  {
    throw new QueryExecutionKernelException(
        new UnstableSnapshotException( "Unable to get clean data snapshot for query serialisation." ) )
        .asUserException();
  }
}

@Test
void shouldThrowOnBeginInExplicitTransaction() throws Exception
{
  QueryExecutionKernelException e = assertThrows( QueryExecutionKernelException.class, () ->
      TransactionStateMachine.State.EXPLICIT_TRANSACTION.beginTransaction( mutableState, stateMachineSPI, null, null, null ) );
  assertEquals( "Nested transactions are not supported.", e.getMessage() );
}

  public QueryExecutionException asUserException()
  {
    return new QueryExecutionException( getMessage(), this, status().code().serialize() );
  }
}

@Override
public Result executeQuery( String query, MapValue parameters, TransactionalContext transactionalContext )
{
  try
  {
    availability.assertDatabaseAvailable();
    return dataSource.neoStoreDataSource.getExecutionEngine().executeQuery( query, parameters, transactionalContext );
  }
  catch ( QueryExecutionKernelException e )
  {
    throw e.asUserException();
  }
}

@Override
State beginTransaction( MutableTransactionState ctx, TransactionStateMachineSPI spi, Bookmark bookmark, Duration txTimeout,
    Map<String,Object> txMetadata ) throws KernelException
{
  throw new QueryExecutionKernelException( new InvalidSemanticsException( "Nested transactions are not supported." ) );
}

  private static QueryExecutionException converted( CypherException e )
  {
    return new QueryExecutionKernelException( e ).asUserException();
  }
}

private void handleException( Output out, QueryExecutionKernelException exception, long startTime )
    throws RemoteException
{
  out.println( (now() - startTime) + " ms" );
  out.println();
  out.println( "WARNING: " + exception.getMessage() );
}

@Override
public Result executeQuery( String query, MapValue parameters, TransactionalContext tc )
{
  try
  {
    availability.assertDatabaseAvailable();
    return sourceModule.neoStoreDataSource.getExecutionEngine().executeQuery( query, parameters, tc );
  }
  catch ( QueryExecutionKernelException e )
  {
    throw e.asUserException();
  }
}

private Result throwQueryExecutionException( String message, Object... parameters ) throws
    QueryExecutionKernelException
{
  throw new QueryExecutionKernelException( new UnstableSnapshotException( message, parameters ) );
}

private void checkIfDirty()
{
  if ( versionContext.isDirty() )
  {
    throw new QueryExecutionKernelException(
        new UnstableSnapshotException( "Unable to get clean data snapshot for query serialisation." ) )
        .asUserException();
  }
}

@Override
State commitTransaction( MutableTransactionState ctx, TransactionStateMachineSPI spi ) throws KernelException
{
  throw new QueryExecutionKernelException( new InvalidSemanticsException( "No current transaction to commit." ) );
}

@Override
public BoltResult start() throws KernelException
{
  try
  {
    Result result = queryExecutionEngine.executeQuery( statement, params, transactionalContext );
    if ( result instanceof QueryResultProvider )
    {
      return newBoltResult( (QueryResultProvider) result, clock );
    }
    else
    {
      throw new IllegalStateException( format( "Unexpected query execution result. Expected to get instance of %s but was %s.",
                           QueryResultProvider.class.getName(), result.getClass().getName() ) );
    }
  }
  catch ( KernelException e )
  {
    close( false );
    throw new QueryExecutionKernelException( e );
  }
  catch ( Throwable e )
  {
    close( false );
    throw e;
  }
}