com.rethinkdb.net

Class Connection

java.lang.Object

com.rethinkdb.net.Connection

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable

public class Connection
extends java.lang.Object
implements java.io.Closeable

A single connection to RethinkDB.

This object is thread-safe.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Connection.Builder Builder should be used to build a Connection instance.

Field Summary

Fields

Modifier and Type	Field and Description
protected @Nullable java.lang.String	dbname
protected @NotNull Result.FetchMode	defaultFetchMode
protected @NotNull java.lang.String	hostname
protected @NotNull java.util.concurrent.atomic.AtomicLong	nextToken
protected @Nullable java.lang.String	password
protected boolean	persistentThreads
protected int	port
protected @Nullable ResponsePump	pump
protected ResponsePump.Factory	pumpFactory
protected @Nullable ConnectionSocket	socket
protected ConnectionSocket.Factory	socketFactory
protected @Nullable javax.net.ssl.SSLContext	sslContext
protected @Nullable java.lang.Long	timeout
protected @NotNull java.util.Set<Result<?>>	tracked
protected boolean	unwrapLists
protected @Nullable java.lang.String	user
protected @NotNull java.util.concurrent.locks.Lock	writeLock

Constructor Summary

Constructors

Constructor and Description
Connection(@NotNull Connection.Builder b) Creates a new connection based on a Connection.Builder.

Method Summary

Modifier and Type	Method and Description
void	close() Closes this connection, closing all Results, the ResponsePump and the ConnectionSocket.
void	close(boolean shouldNoreplyWait) Closes this connection, closing all Results, the ResponsePump and the ConnectionSocket.
@NotNull java.util.concurrent.CompletableFuture<java.lang.Void>	closeAsync() Closes this connection asynchronously, closing all Results, the ResponsePump and the ConnectionSocket.
@NotNull java.util.concurrent.CompletableFuture<java.lang.Void>	closeAsync(boolean shouldNoreplyWait) Closes this connection asynchronously, closing all Results, the ResponsePump and the ConnectionSocket.
void	closeResults() Closes all Results currently opened.
@NotNull Connection	connect() Begins the socket connection to the server.
@NotNull java.util.concurrent.CompletableFuture<Connection>	connectAsync() Begins the socket connection to the server asynchronously.
protected @NotNull java.util.concurrent.CompletableFuture<ConnectionSocket>	createSocketAsync() Detects if the connection socket supports async creation or wraps it before returning.
@Nullable java.lang.String	db() Gets the default database of the server.
protected void	handleOptArgs(@NotNull OptArgs optArgs) Handle optArgs before sending to the server.
boolean	hasOngoingQueries() Checks if there are any ongoing query.
boolean	isOpen() Checks if the connection is open.
protected void	keepTrackOf(@NotNull Result<?> r) Callback method from Result, signals that this connection should keep track of this result.
protected void	loseTrackOf(@NotNull Result<?> r) Callback method from Result, signals that this connection should no long keep track of this result.
void	noreplyWait() Runs a noreply_wait query to the server and awaits it.
@NotNull java.util.concurrent.CompletableFuture<java.lang.Void>	noreplyWaitAsync() Runs a noreply_wait query to the server and awaits it asynchronously.
@NotNull Connection	reconnect() Closes and reconnects to the server.
@NotNull Connection	reconnect(boolean noreplyWait) Closes and reconnects to the server.
@NotNull java.util.concurrent.CompletableFuture<Connection>	reconnectAsync() Closes and reconnects to the server.
@NotNull java.util.concurrent.CompletableFuture<Connection>	reconnectAsync(boolean noreplyWait) Closes and reconnects to the server asynchronously.
<T> @NotNull Result<T>	run(@NotNull ReqlAst term, @NotNull OptArgs optArgs, @Nullable Result.FetchMode fetchMode, @Nullable java.lang.Boolean unwrap, @Nullable com.fasterxml.jackson.core.type.TypeReference<T> typeRef) Runs a ReQL query with options optArgs, the specified fetchMode and returns the result, with the values converted to the type of TypeReference<T>
<T> @NotNull java.util.concurrent.CompletableFuture<Result<T>>	runAsync(@NotNull ReqlAst term, @NotNull OptArgs optArgs, @Nullable Result.FetchMode fetchMode, @Nullable java.lang.Boolean unwrap, @Nullable com.fasterxml.jackson.core.type.TypeReference<T> typeRef) Runs a ReQL query with options optArgs, the specified fetchMode and returns the result asynchronously, with the values converted to the type of TypeReference<T>
void	runNoReply(@NotNull ReqlAst term, @NotNull OptArgs optArgs) Runs this query via connection conn with options optArgs without awaiting the response.
protected <T> @NotNull java.util.concurrent.CompletableFuture<Result<T>>	runQuery(@NotNull Query query, @Nullable Result.FetchMode fetchMode, @Nullable java.lang.Boolean unwrap, @Nullable com.fasterxml.jackson.core.type.TypeReference<T> typeRef) Sents a query to the server and returns a CompletableFuture which completes with a result.
protected void	runQueryNoreply(@NotNull Query query) Writes a query without waiting for a response
protected @NotNull java.util.concurrent.CompletableFuture<Response>	sendContinue(long token) Sends a CONTINUE query.
protected @NotNull java.util.concurrent.CompletableFuture<Response>	sendQuery(@NotNull Query query) Writes a query and returns a completable future.
protected void	sendStop(long token) Sends a STOP query.
@NotNull Server	server() Runs a server_info query to the server and returns the server info.
@NotNull java.util.concurrent.CompletableFuture<Server>	serverAsync() Runs a server_info query to the server and returns the server info asynchronously.
@NotNull Connection	use(@Nullable java.lang.String db) Sets the default database of the server.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

hostname

@NotNull
protected final @NotNull java.lang.String hostname

port

protected final int port

user

@Nullable
protected final @Nullable java.lang.String user

password

@Nullable
protected final @Nullable java.lang.String password

timeout

@Nullable
protected final @Nullable java.lang.Long timeout

sslContext

@Nullable
protected final @Nullable javax.net.ssl.SSLContext sslContext

socketFactory

@NotNull
protected final ConnectionSocket.Factory socketFactory

pumpFactory

@NotNull
protected final ResponsePump.Factory pumpFactory

defaultFetchMode

@NotNull
protected final @NotNull Result.FetchMode defaultFetchMode

unwrapLists

protected final boolean unwrapLists

persistentThreads

protected final boolean persistentThreads

nextToken

@NotNull
protected final @NotNull java.util.concurrent.atomic.AtomicLong nextToken

tracked

@NotNull
protected final @NotNull java.util.Set<Result<?>> tracked

writeLock

@NotNull
protected final @NotNull java.util.concurrent.locks.Lock writeLock

dbname

@Nullable
protected @Nullable java.lang.String dbname

socket

@Nullable
protected @Nullable ConnectionSocket socket

pump

@Nullable
protected @Nullable ResponsePump pump

Constructor Detail

Connection

public Connection(@NotNull
                  @NotNull Connection.Builder b)

Creates a new connection based on a Connection.Builder.

Parameters:

b - the connection builder

Method Detail

db

@Nullable
public @Nullable java.lang.String db()

Gets the default database of the server.
To set the default database, use Connection.Builder.db(String) or use(String)

Returns:

the current default database, if any, of null.

use

@NotNull
public @NotNull Connection use(@Nullable
                                        @Nullable java.lang.String db)

Sets the default database of the server.

Parameters:

db - the new current default database.

Returns:

itself.

isOpen

public boolean isOpen()

Checks if the connection is open.

Returns:

true if the socket and the response pump are working, otherwise false.

connectAsync

@NotNull
public @NotNull java.util.concurrent.CompletableFuture<Connection> connectAsync()

Begins the socket connection to the server asynchronously.

Returns:

a CompletableFuture which completes with itself, once connected.

connect

@NotNull
public @NotNull Connection connect()

Begins the socket connection to the server.

Returns:

itself, once connected.

reconnectAsync

@NotNull
public @NotNull java.util.concurrent.CompletableFuture<Connection> reconnectAsync()

Closes and reconnects to the server.

Returns:

a CompletableFuture which completes with itself, once reconnected.

reconnectAsync

@NotNull
public @NotNull java.util.concurrent.CompletableFuture<Connection> reconnectAsync(boolean noreplyWait)

Closes and reconnects to the server asynchronously.

Parameters:

noreplyWait - if closing should send a noreplyWait() before closing.

Returns:

a CompletableFuture which completes with itself, once reconnected.

reconnect

@NotNull
public @NotNull Connection reconnect()

Closes and reconnects to the server.

Returns:

itself, once reconnected.

reconnect

@NotNull
public @NotNull Connection reconnect(boolean noreplyWait)

Closes and reconnects to the server.

Parameters:

noreplyWait - if closing should send a noreplyWait() before closing.

Returns:

itself, once reconnected.

runAsync

@NotNull
public <T> @NotNull java.util.concurrent.CompletableFuture<Result<T>> runAsync(@NotNull
                                                                                        @NotNull ReqlAst term,
                                                                                        @NotNull
                                                                                        @NotNull OptArgs optArgs,
                                                                                        @Nullable
                                                                                        @Nullable Result.FetchMode fetchMode,
                                                                                        @Nullable
                                                                                        @Nullable java.lang.Boolean unwrap,
                                                                                        @Nullable
                                                                                        @Nullable com.fasterxml.jackson.core.type.TypeReference<T> typeRef)

Runs a ReQL query with options optArgs, the specified fetchMode and returns the result asynchronously, with the values converted to the type of TypeReference<T>

Type Parameters:

T - The type of result

Parameters:

term - The ReQL term

optArgs - The options to run this query with

fetchMode - The fetch mode to use in partial sequences

unwrap - Override for the connection's unwrapLists setting

typeRef - The type to convert to

Returns:

The result of this query

run

@NotNull
public <T> @NotNull Result<T> run(@NotNull
                                           @NotNull ReqlAst term,
                                           @NotNull
                                           @NotNull OptArgs optArgs,
                                           @Nullable
                                           @Nullable Result.FetchMode fetchMode,
                                           @Nullable
                                           @Nullable java.lang.Boolean unwrap,
                                           @Nullable
                                           @Nullable com.fasterxml.jackson.core.type.TypeReference<T> typeRef)

Runs a ReQL query with options optArgs, the specified fetchMode and returns the result, with the values converted to the type of TypeReference<T>

Type Parameters:

T - The type of result

Parameters:

term - The ReQL term

optArgs - The options to run this query with

fetchMode - The fetch mode to use in partial sequences

unwrap - Override for the connection's unwrapLists setting

typeRef - The type to convert to

Returns:

The result of this query

serverAsync

@NotNull
public @NotNull java.util.concurrent.CompletableFuture<Server> serverAsync()

Runs a server_info query to the server and returns the server info asynchronously.

Returns:

The server info.

server

@NotNull
public @NotNull Server server()

Runs a server_info query to the server and returns the server info.

Returns:

The server info.

noreplyWaitAsync

@NotNull
public @NotNull java.util.concurrent.CompletableFuture<java.lang.Void> noreplyWaitAsync()

Runs a noreply_wait query to the server and awaits it asynchronously.

Returns:

a CompletableFuture you can await.

noreplyWait

public void noreplyWait()

Runs a noreply_wait query to the server and awaits it.

runNoReply

public void runNoReply(@NotNull
                       @NotNull ReqlAst term,
                       @NotNull
                       @NotNull OptArgs optArgs)

Runs this query via connection conn with options optArgs without awaiting the response.

Parameters:

term - The ReQL term

optArgs - The options to run this query with

closeAsync

@NotNull
public @NotNull java.util.concurrent.CompletableFuture<java.lang.Void> closeAsync()

Closes this connection asynchronously, closing all Results, the ResponsePump and the ConnectionSocket.

Returns:

a CompletableFuture which completes when everything is closed.

closeAsync

@NotNull
public @NotNull java.util.concurrent.CompletableFuture<java.lang.Void> closeAsync(boolean shouldNoreplyWait)

Closes this connection asynchronously, closing all Results, the ResponsePump and the ConnectionSocket.

Parameters:

shouldNoreplyWait - If the connection should noreply_wait before closing

Returns:

a CompletableFuture which completes when everything is closed.

close

public void close()

Closes this connection, closing all Results, the ResponsePump and the ConnectionSocket.

Specified by:

close in interface java.io.Closeable

Specified by:

close in interface java.lang.AutoCloseable

close

public void close(boolean shouldNoreplyWait)

Closes this connection, closing all Results, the ResponsePump and the ConnectionSocket.

Parameters:

shouldNoreplyWait - If the connection should noreply_wait before closing

closeResults

public void closeResults()

Closes all Results currently opened.

hasOngoingQueries

public boolean hasOngoingQueries()

Checks if there are any ongoing query.

Returns:

true if there's an ongoing query that will be closed if this connection is closed.

sendStop

protected void sendStop(long token)

Sends a STOP query. Used by Result partial sequences.

Parameters:

token - the response token.

sendContinue

@NotNull
protected @NotNull java.util.concurrent.CompletableFuture<Response> sendContinue(long token)

Sends a CONTINUE query. Used by Result partial sequences.

Parameters:

token - the response token.

Returns:

a completable future which completes with the next response.

keepTrackOf

protected void keepTrackOf(@NotNull
                           @NotNull Result<?> r)

Callback method from Result, signals that this connection should keep track of this result. Tracked results can be closed using close() or closeResults().

Parameters:

r - the result to be tracked.

loseTrackOf

protected void loseTrackOf(@NotNull
                           @NotNull Result<?> r)

Callback method from Result, signals that this connection should no long keep track of this result. The result probably finished or was closed.

Parameters:

r - the result to be tracked.

sendQuery

@NotNull
protected @NotNull java.util.concurrent.CompletableFuture<Response> sendQuery(@NotNull
                                                                                       @NotNull Query query)

Writes a query and returns a completable future. Said completable future value will eventually be set by the runnable response pump (see connect()).

Parameters:

query - the query to execute.

Returns:

a completable future.

runQueryNoreply

protected void runQueryNoreply(@NotNull
                               @NotNull Query query)

Writes a query without waiting for a response

Parameters:

query - the query to execute.

runQuery

@NotNull
protected <T> @NotNull java.util.concurrent.CompletableFuture<Result<T>> runQuery(@NotNull
                                                                                           @NotNull Query query,
                                                                                           @Nullable
                                                                                           @Nullable Result.FetchMode fetchMode,
                                                                                           @Nullable
                                                                                           @Nullable java.lang.Boolean unwrap,
                                                                                           @Nullable
                                                                                           @Nullable com.fasterxml.jackson.core.type.TypeReference<T> typeRef)

Sents a query to the server and returns a CompletableFuture which completes with a result. Runs a ReQL query with options optArgs, the specified fetchMode and returns the result, with the values converted to the type of TypeReference<T>

Type Parameters:

T - The type of result

Parameters:

query - The query

fetchMode - The fetch mode to use in partial sequences

unwrap - Override for the connection's unwrapLists setting

typeRef - The type to convert to

Returns:

The CompletableFuture which completes with the result of the query.

handleOptArgs

protected void handleOptArgs(@NotNull
                             @NotNull OptArgs optArgs)

Handle optArgs before sending to the server.

Parameters:

optArgs - the optArgs.

createSocketAsync

@NotNull
protected @NotNull java.util.concurrent.CompletableFuture<ConnectionSocket> createSocketAsync()

Detects if the connection socket supports async creation or wraps it before returning.

Returns:

a CompletableFuture which will complete with a new ConnectionSocket.