This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
Overview
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
Package
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
Interfaces (italic)
Classes
Enums
Exceptions
Errors
Annotation Types
Class/Interface
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
Class inheritance diagram
Direct Subclasses
All Known Subinterfaces
All Known Implementing Classes
Class/interface declaration
Class/interface description
Nested Class Summary
Field Summary
Constructor Summary
Method Summary
Field Detail
Constructor Detail
Method Detail
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
Annotation Type
Each annotation type has its own separate page with the following sections:
Annotation Type declaration
Annotation Type description
Required Element Summary
Optional Element Summary
Element Detail
Enum
Each enum has its own separate page with the following sections:
Enum declaration
Enum description
Enum Constant Summary
Enum Constant Detail
Use
Each documented package, class and interface has its own Use page. This page describes what packages, classes, methods, constructors and fields use any part of the given class or package. Given a class or interface A, its Use page includes subclasses of A, fields declared as A, methods that return A, and methods and constructors with parameters of type A. You can access this page by first going to the package, class or interface, then clicking on the "Use" link in the navigation bar.
Tree (Class Hierarchy)
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
Deprecated API
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
Index
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
Prev/Next
These links take you to the next or previous class, interface, package, or related page.
Frames/No Frames
These links show and hide the HTML frames. All pages are available with or without frames.
All Classes
The All Classes link shows all classes and interfaces except non-static nested types.
Serialized Form
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.
Provide a PgConnectOptions configured with environment variables, if the environment variable
is not set, then a default value will take precedence over this.
Provide a PgPoolOptions configured with environment variables, if the environment variable
is not set, then a default value will take precedence over this.
Connects to the database and returns the connection if that succeeds.
The connection interracts directly with the database is not a proxy, so closing the
connection will close the underlying connection to the database.
Parameters:
vertx - the vertx instance
options - the connect options
handler - the handler called with the connection or the failure
Provide a PgConnectOptions configured with environment variables, if the environment variable
is not set, then a default value will take precedence over this.
Provide a PgConnectOptions configured with environment variables, if the environment variable
is not set, then a default value will take precedence over this.
Begin a transaction and returns a PgTransaction for controlling and tracking
this transaction.
When the connection is explicitely closed, any inflight transaction is rollbacked.
Set an handler called when the connection receives notification on a channel.
The handler is called with the PgNotification and has access to the channel name
and the notification payload.
Send a request cancellation message to tell the server to cancel processing request in this connection.
Note: Use this with caution because the cancellation signal may or may not have any effect.
Parameters:
handler - the handler notified if cancelling request is sent
Returns:
a reference to this, so the API can be used fluently
isSSL
boolean isSSL()
Returns:
whether the connection uses SSL
close
void close()
Close the current connection after all the pending commands have been processed.
Provide a PgPoolOptions configured with environment variables, if the environment variable
is not set, then a default value will take precedence over this.
Provide a PgPoolOptions configured with environment variables, if the environment variable
is not set, then a default value will take precedence over this.
a reference to this, so the API can be used fluently
getMaxWaitQueueSize
public int getMaxWaitQueueSize()
Returns:
the maximum wait queue size
setMaxWaitQueueSize
public PgPoolOptions setMaxWaitQueueSize(int maxWaitQueueSize)
Set the maximum connection request allowed in the wait queue, any requests beyond the max size will result in
an failure. If the value is set to a negative number then the queue will be unbounded.
Parameters:
maxWaitQueueSize - the maximum number of waiting requests
Returns:
a reference to this, so the API can be used fluently
Execute the prepared query with a cursor and createStream the result. The createStream opens a cursor
with a fetch size to fetch the results.
Note: this requires to be in a transaction, since cursors require it.
only try an SSL connection, verify that the server certificate is issued by a trusted CA and that the requested server host name matches that in the certificate.
only try an SSL connection, verify that the server certificate is issued by a trusted CA and that the requested server host name matches that in the certificate.
Returns an array containing the constants of this enum type, in
the order they are declared. This method may be used to iterate
over the constants as follows:
for (SslMode c : SslMode.values())
System.out.println(c);
Returns:
an array containing the constants of this enum type, in the order they are declared
Returns the enum constant of this type with the specified name.
The string must match exactly an identifier used to declare an
enum constant in this type. (Extraneous whitespace characters are
not permitted.)
Parameters:
name - the name of the enum constant to be returned.
Provide a PgConnectOptions configured with environment variables, if the environment variable
is not set, then a default value will take precedence over this.
Provide a PgPoolOptions configured with environment variables, if the environment variable
is not set, then a default value will take precedence over this.
Path data type in Postgres represented by lists of connected points.
Paths can be open, where the first and last points in the list are considered not connected,
or closed, where the first and last points are considered connected.
Polygon data type in Postgres represented by lists of points (the vertexes of the polygon).
Polygons are very similar to closed paths, but are stored differently and have their own set of support routines.
public interface PgChannel
extends io.vertx.core.streams.ReadStream<String>
A channel to Postgres that tracks the subscription to a given Postgres channel using the LISTEN/UNLISTEN commands.
When paused the channel discards the messages.
name - the channel name
This will be the name of the channel exactly as held by Postgres for sending
notifications. Internally this name will be truncated to the Postgres identifier
maxiumum length of (NAMEDATALEN = 64) - 1 == 63 characters, and prepared
as a quoted identifier without unicode escape sequence support for use in
LISTEN/UNLISTEN commands. Examples of channel names and corresponding
NOTIFY commands:
when name == "the_channel": NOTIFY the_channel, 'msg',
NOTIFY The_Channel, 'msg', or NOTIFY "the_channel", 'msg'
succeed in delivering a message to the created channel
when name == "The_Channel": NOTIFY "The_Channel", 'msg',
succeeds in delivering a message to the created channel
Set the reconnect policy that is executed when the subscriber is disconnected.
When the subscriber is disconnected, the policy function is called with the actual
number of retries and returns an amountOfTime value:
when amountOfTime < 0: the subscriber is closed and there is no retry
when amountOfTime == 0: the subscriber retries to connect immediately
when amountOfTime > 0: the subscriber retries after amountOfTime milliseconds
The default policy does not perform any retries.
Parameters:
policy - the policy to set
Returns:
a reference to this, so the API can be used fluently
Defines the client operations with a Postgres Database.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
public static void connect(io.vertx.reactivex.core.Vertx vertx,
PgConnectOptions options,
io.vertx.core.Handler<io.vertx.core.AsyncResult<PgConnection>> handler)
Connects to the database and returns the connection if that succeeds.
The connection interracts directly with the database is not a proxy, so closing the
connection will close the underlying connection to the database.
Parameters:
vertx - the vertx instance
options - the connect options
handler - the handler called with the connection or the failure
Connects to the database and returns the connection if that succeeds.
The connection interracts directly with the database is not a proxy, so closing the
connection will close the underlying connection to the database.
Parameters:
vertx - the vertx instance
options - the connect options
Returns:
connect
public static void connect(io.vertx.reactivex.core.Vertx vertx,
io.vertx.core.Handler<io.vertx.core.AsyncResult<PgConnection>> handler)
Begin a transaction and returns a PgTransaction for controlling and tracking
this transaction.
When the connection is explicitely closed, any inflight transaction is rollbacked.
Set an handler called when the connection receives notification on a channel.
The handler is called with the PgNotification and has access to the channel name
and the notification payload.
Parameters:
handler - the handler
Returns:
the transaction instance
processId
public int processId()
Returns:
The process ID of the target backend
secretKey
public int secretKey()
Returns:
The secret key for the target backend
cancelRequest
public PgConnection cancelRequest(io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> handler)
Send a request cancellation message to tell the server to cancel processing request in this connection.
Note: Use this with caution because the cancellation signal may or may not have any effect.
Parameters:
handler - the handler notified if cancelling request is sent
Returns:
a reference to this, so the API can be used fluently
isSSL
public boolean isSSL()
Returns:
whether the connection uses SSL
close
public void close()
Close the current connection after all the pending commands have been processed.
preparedQuery
public PgConnection preparedQuery(String sql,
io.vertx.core.Handler<io.vertx.core.AsyncResult<PgRowSet>> handler)
A cursor that reads progressively the rows from Postgres, it is usefull for reading very large result.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
An iterator for processing postgres items synchronously.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
Execute the prepared query with a cursor and createStream the result. The createStream opens a cursor
with a fetch size to fetch the results.
Note: this requires to be in a transaction, since cursors require it.
Represents the result of an operation on database.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
A transaction that allows to control the transaction and receive events.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
public class PgChannel
extends Object
implements io.vertx.reactivex.core.streams.ReadStream<String>
A channel to Postgres that tracks the subscription to a given Postgres channel using the LISTEN/UNLISTEN commands.
When paused the channel discards the messages.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
A class for managing subscriptions using LISTEN/UNLISTEN to Postgres channels.
The subscriber manages a single connection to Postgres.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
name - the channel name This will be the name of the channel exactly as held by Postgres for sending notifications. Internally this name will be truncated to the Postgres identifier maxiumum length of (NAMEDATALEN = 64) - 1 == 63 characters, and prepared as a quoted identifier without unicode escape sequence support for use in LISTEN/UNLISTEN commands. Examples of channel names and corresponding NOTIFY commands:
when name == "the_channel": NOTIFY the_channel, 'msg', NOTIFY The_Channel, 'msg', or NOTIFY "the_channel", 'msg' succeed in delivering a message to the created channel
when name == "The_Channel": NOTIFY "The_Channel", 'msg', succeeds in delivering a message to the created channel
Returns:
the channel
connect
public PgSubscriber connect(io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> handler)
Connect the subscriber to Postgres.
Parameters:
handler - the handler notified of the connection success or failure
Returns:
a reference to this, so the API can be used fluently
Set the reconnect policy that is executed when the subscriber is disconnected.
When the subscriber is disconnected, the policy function is called with the actual
number of retries and returns an amountOfTime value:
when amountOfTime < 0: the subscriber is closed and there is no retry
when amountOfTime == 0: the subscriber retries to connect immediately
when amountOfTime > 0: the subscriber retries after amountOfTime milliseconds
The default policy does not perform any retries.
Parameters:
policy - the policy to set
Returns:
a reference to this, so the API can be used fluently
closeHandler
public PgSubscriber closeHandler(io.vertx.core.Handler<Void> handler)
Set an handler called when the subscriber is closed.
Parameters:
handler - the handler
Returns:
a reference to this, so the API can be used fluently
Defines the client operations with a Postgres Database.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
public static void connect(io.vertx.rxjava.core.Vertx vertx,
PgConnectOptions options,
io.vertx.core.Handler<io.vertx.core.AsyncResult<PgConnection>> handler)
Connects to the database and returns the connection if that succeeds.
The connection interracts directly with the database is not a proxy, so closing the
connection will close the underlying connection to the database.
Parameters:
vertx - the vertx instance
options - the connect options
handler - the handler called with the connection or the failure
Connects to the database and returns the connection if that succeeds.
The connection interracts directly with the database is not a proxy, so closing the
connection will close the underlying connection to the database.
Parameters:
vertx - the vertx instance
options - the connect options
Returns:
connect
public static void connect(io.vertx.rxjava.core.Vertx vertx,
io.vertx.core.Handler<io.vertx.core.AsyncResult<PgConnection>> handler)
Begin a transaction and returns a PgTransaction for controlling and tracking
this transaction.
When the connection is explicitely closed, any inflight transaction is rollbacked.
Set an handler called when the connection receives notification on a channel.
The handler is called with the PgNotification and has access to the channel name
and the notification payload.
Parameters:
handler - the handler
Returns:
the transaction instance
processId
public int processId()
Returns:
The process ID of the target backend
secretKey
public int secretKey()
Returns:
The secret key for the target backend
cancelRequest
public PgConnection cancelRequest(io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> handler)
Send a request cancellation message to tell the server to cancel processing request in this connection.
Note: Use this with caution because the cancellation signal may or may not have any effect.
Parameters:
handler - the handler notified if cancelling request is sent
Returns:
a reference to this, so the API can be used fluently
isSSL
public boolean isSSL()
Returns:
whether the connection uses SSL
close
public void close()
Close the current connection after all the pending commands have been processed.
preparedQuery
public PgConnection preparedQuery(String sql,
io.vertx.core.Handler<io.vertx.core.AsyncResult<PgRowSet>> handler)
A cursor that reads progressively the rows from Postgres, it is usefull for reading very large result.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
An iterator for processing postgres items synchronously.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
Execute the prepared query with a cursor and createStream the result. The createStream opens a cursor
with a fetch size to fetch the results.
Note: this requires to be in a transaction, since cursors require it.
Represents the result of an operation on database.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
A transaction that allows to control the transaction and receive events.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
public class PgChannel
extends Object
implements io.vertx.rxjava.core.streams.ReadStream<String>
A channel to Postgres that tracks the subscription to a given Postgres channel using the LISTEN/UNLISTEN commands.
When paused the channel discards the messages.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
A class for managing subscriptions using LISTEN/UNLISTEN to Postgres channels.
The subscriber manages a single connection to Postgres.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
name - the channel name This will be the name of the channel exactly as held by Postgres for sending notifications. Internally this name will be truncated to the Postgres identifier maxiumum length of (NAMEDATALEN = 64) - 1 == 63 characters, and prepared as a quoted identifier without unicode escape sequence support for use in LISTEN/UNLISTEN commands. Examples of channel names and corresponding NOTIFY commands:
when name == "the_channel": NOTIFY the_channel, 'msg', NOTIFY The_Channel, 'msg', or NOTIFY "the_channel", 'msg' succeed in delivering a message to the created channel
when name == "The_Channel": NOTIFY "The_Channel", 'msg', succeeds in delivering a message to the created channel
Returns:
the channel
connect
public PgSubscriber connect(io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> handler)
Connect the subscriber to Postgres.
Parameters:
handler - the handler notified of the connection success or failure
Returns:
a reference to this, so the API can be used fluently
Set the reconnect policy that is executed when the subscriber is disconnected.
When the subscriber is disconnected, the policy function is called with the actual
number of retries and returns an amountOfTime value:
when amountOfTime < 0: the subscriber is closed and there is no retry
when amountOfTime == 0: the subscriber retries to connect immediately
when amountOfTime > 0: the subscriber retries after amountOfTime milliseconds
The default policy does not perform any retries.
Parameters:
policy - the policy to set
Returns:
a reference to this, so the API can be used fluently
closeHandler
public PgSubscriber closeHandler(io.vertx.core.Handler<Void> handler)
Set an handler called when the subscriber is closed.
Parameters:
handler - the handler
Returns:
a reference to this, so the API can be used fluently
================================================
FILE: docs/apidocs/stylesheet.css
================================================
/* Javadoc style sheet */
/*
Overall document style
*/
@import url('resources/fonts/dejavu.css');
body {
background-color:#ffffff;
color:#353833;
font-family:'DejaVu Sans', Arial, Helvetica, sans-serif;
font-size:14px;
margin:0;
}
a:link, a:visited {
text-decoration:none;
color:#4A6782;
}
a:hover, a:focus {
text-decoration:none;
color:#bb7a2a;
}
a:active {
text-decoration:none;
color:#4A6782;
}
a[name] {
color:#353833;
}
a[name]:hover {
text-decoration:none;
color:#353833;
}
pre {
font-family:'DejaVu Sans Mono', monospace;
font-size:14px;
}
h1 {
font-size:20px;
}
h2 {
font-size:18px;
}
h3 {
font-size:16px;
font-style:italic;
}
h4 {
font-size:13px;
}
h5 {
font-size:12px;
}
h6 {
font-size:11px;
}
ul {
list-style-type:disc;
}
code, tt {
font-family:'DejaVu Sans Mono', monospace;
font-size:14px;
padding-top:4px;
margin-top:8px;
line-height:1.4em;
}
dt code {
font-family:'DejaVu Sans Mono', monospace;
font-size:14px;
padding-top:4px;
}
table tr td dt code {
font-family:'DejaVu Sans Mono', monospace;
font-size:14px;
vertical-align:top;
padding-top:4px;
}
sup {
font-size:8px;
}
/*
Document title and Copyright styles
*/
.clear {
clear:both;
height:0px;
overflow:hidden;
}
.aboutLanguage {
float:right;
padding:0px 21px;
font-size:11px;
z-index:200;
margin-top:-9px;
}
.legalCopy {
margin-left:.5em;
}
.bar a, .bar a:link, .bar a:visited, .bar a:active {
color:#FFFFFF;
text-decoration:none;
}
.bar a:hover, .bar a:focus {
color:#bb7a2a;
}
.tab {
background-color:#0066FF;
color:#ffffff;
padding:8px;
width:5em;
font-weight:bold;
}
/*
Navigation bar styles
*/
.bar {
background-color:#4D7A97;
color:#FFFFFF;
padding:.8em .5em .4em .8em;
height:auto;/*height:1.8em;*/
font-size:11px;
margin:0;
}
.topNav {
background-color:#4D7A97;
color:#FFFFFF;
float:left;
padding:0;
width:100%;
clear:right;
height:2.8em;
padding-top:10px;
overflow:hidden;
font-size:12px;
}
.bottomNav {
margin-top:10px;
background-color:#4D7A97;
color:#FFFFFF;
float:left;
padding:0;
width:100%;
clear:right;
height:2.8em;
padding-top:10px;
overflow:hidden;
font-size:12px;
}
.subNav {
background-color:#dee3e9;
float:left;
width:100%;
overflow:hidden;
font-size:12px;
}
.subNav div {
clear:left;
float:left;
padding:0 0 5px 6px;
text-transform:uppercase;
}
ul.navList, ul.subNavList {
float:left;
margin:0 25px 0 0;
padding:0;
}
ul.navList li{
list-style:none;
float:left;
padding: 5px 6px;
text-transform:uppercase;
}
ul.subNavList li{
list-style:none;
float:left;
}
.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited {
color:#FFFFFF;
text-decoration:none;
text-transform:uppercase;
}
.topNav a:hover, .bottomNav a:hover {
text-decoration:none;
color:#bb7a2a;
text-transform:uppercase;
}
.navBarCell1Rev {
background-color:#F8981D;
color:#253441;
margin: auto 5px;
}
.skipNav {
position:absolute;
top:auto;
left:-9999px;
overflow:hidden;
}
/*
Page header and footer styles
*/
.header, .footer {
clear:both;
margin:0 20px;
padding:5px 0 0 0;
}
.indexHeader {
margin:10px;
position:relative;
}
.indexHeader span{
margin-right:15px;
}
.indexHeader h1 {
font-size:13px;
}
.title {
color:#2c4557;
margin:10px 0;
}
.subTitle {
margin:5px 0 0 0;
}
.header ul {
margin:0 0 15px 0;
padding:0;
}
.footer ul {
margin:20px 0 5px 0;
}
.header ul li, .footer ul li {
list-style:none;
font-size:13px;
}
/*
Heading styles
*/
div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 {
background-color:#dee3e9;
border:1px solid #d0d9e0;
margin:0 0 6px -8px;
padding:7px 5px;
}
ul.blockList ul.blockList ul.blockList li.blockList h3 {
background-color:#dee3e9;
border:1px solid #d0d9e0;
margin:0 0 6px -8px;
padding:7px 5px;
}
ul.blockList ul.blockList li.blockList h3 {
padding:0;
margin:15px 0;
}
ul.blockList li.blockList h2 {
padding:0px 0 20px 0;
}
/*
Page layout container styles
*/
.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer {
clear:both;
padding:10px 20px;
position:relative;
}
.indexContainer {
margin:10px;
position:relative;
font-size:12px;
}
.indexContainer h2 {
font-size:13px;
padding:0 0 3px 0;
}
.indexContainer ul {
margin:0;
padding:0;
}
.indexContainer ul li {
list-style:none;
padding-top:2px;
}
.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt {
font-size:12px;
font-weight:bold;
margin:10px 0 0 0;
color:#4E4E4E;
}
.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd {
margin:5px 0 10px 0px;
font-size:14px;
font-family:'DejaVu Sans Mono',monospace;
}
.serializedFormContainer dl.nameValue dt {
margin-left:1px;
font-size:1.1em;
display:inline;
font-weight:bold;
}
.serializedFormContainer dl.nameValue dd {
margin:0 0 0 1px;
font-size:1.1em;
display:inline;
}
/*
List styles
*/
ul.horizontal li {
display:inline;
font-size:0.9em;
}
ul.inheritance {
margin:0;
padding:0;
}
ul.inheritance li {
display:inline;
list-style:none;
}
ul.inheritance li ul.inheritance {
margin-left:15px;
padding-left:15px;
padding-top:1px;
}
ul.blockList, ul.blockListLast {
margin:10px 0 10px 0;
padding:0;
}
ul.blockList li.blockList, ul.blockListLast li.blockList {
list-style:none;
margin-bottom:15px;
line-height:1.4;
}
ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList {
padding:0px 20px 5px 10px;
border:1px solid #ededed;
background-color:#f8f8f8;
}
ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList {
padding:0 0 5px 8px;
background-color:#ffffff;
border:none;
}
ul.blockList ul.blockList ul.blockList ul.blockList li.blockList {
margin-left:0;
padding-left:0;
padding-bottom:15px;
border:none;
}
ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast {
list-style:none;
border-bottom:none;
padding-bottom:0;
}
table tr td dl, table tr td dl dt, table tr td dl dd {
margin-top:0;
margin-bottom:1px;
}
/*
Table styles
*/
.overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary {
width:100%;
border-left:1px solid #EEE;
border-right:1px solid #EEE;
border-bottom:1px solid #EEE;
}
.overviewSummary, .memberSummary {
padding:0px;
}
.overviewSummary caption, .memberSummary caption, .typeSummary caption,
.useSummary caption, .constantsSummary caption, .deprecatedSummary caption {
position:relative;
text-align:left;
background-repeat:no-repeat;
color:#253441;
font-weight:bold;
clear:none;
overflow:hidden;
padding:0px;
padding-top:10px;
padding-left:1px;
margin:0px;
white-space:pre;
}
.overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link,
.useSummary caption a:link, .constantsSummary caption a:link, .deprecatedSummary caption a:link,
.overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover,
.useSummary caption a:hover, .constantsSummary caption a:hover, .deprecatedSummary caption a:hover,
.overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active,
.useSummary caption a:active, .constantsSummary caption a:active, .deprecatedSummary caption a:active,
.overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited,
.useSummary caption a:visited, .constantsSummary caption a:visited, .deprecatedSummary caption a:visited {
color:#FFFFFF;
}
.overviewSummary caption span, .memberSummary caption span, .typeSummary caption span,
.useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span {
white-space:nowrap;
padding-top:5px;
padding-left:12px;
padding-right:12px;
padding-bottom:7px;
display:inline-block;
float:left;
background-color:#F8981D;
border: none;
height:16px;
}
.memberSummary caption span.activeTableTab span {
white-space:nowrap;
padding-top:5px;
padding-left:12px;
padding-right:12px;
margin-right:3px;
display:inline-block;
float:left;
background-color:#F8981D;
height:16px;
}
.memberSummary caption span.tableTab span {
white-space:nowrap;
padding-top:5px;
padding-left:12px;
padding-right:12px;
margin-right:3px;
display:inline-block;
float:left;
background-color:#4D7A97;
height:16px;
}
.memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab {
padding-top:0px;
padding-left:0px;
padding-right:0px;
background-image:none;
float:none;
display:inline;
}
.overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd,
.useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd {
display:none;
width:5px;
position:relative;
float:left;
background-color:#F8981D;
}
.memberSummary .activeTableTab .tabEnd {
display:none;
width:5px;
margin-right:3px;
position:relative;
float:left;
background-color:#F8981D;
}
.memberSummary .tableTab .tabEnd {
display:none;
width:5px;
margin-right:3px;
position:relative;
background-color:#4D7A97;
float:left;
}
.overviewSummary td, .memberSummary td, .typeSummary td,
.useSummary td, .constantsSummary td, .deprecatedSummary td {
text-align:left;
padding:0px 0px 12px 10px;
}
th.colOne, th.colFirst, th.colLast, .useSummary th, .constantsSummary th,
td.colOne, td.colFirst, td.colLast, .useSummary td, .constantsSummary td{
vertical-align:top;
padding-right:0px;
padding-top:8px;
padding-bottom:3px;
}
th.colFirst, th.colLast, th.colOne, .constantsSummary th {
background:#dee3e9;
text-align:left;
padding:8px 3px 3px 7px;
}
td.colFirst, th.colFirst {
white-space:nowrap;
font-size:13px;
}
td.colLast, th.colLast {
font-size:13px;
}
td.colOne, th.colOne {
font-size:13px;
}
.overviewSummary td.colFirst, .overviewSummary th.colFirst,
.useSummary td.colFirst, .useSummary th.colFirst,
.overviewSummary td.colOne, .overviewSummary th.colOne,
.memberSummary td.colFirst, .memberSummary th.colFirst,
.memberSummary td.colOne, .memberSummary th.colOne,
.typeSummary td.colFirst{
width:25%;
vertical-align:top;
}
td.colOne a:link, td.colOne a:active, td.colOne a:visited, td.colOne a:hover, td.colFirst a:link, td.colFirst a:active, td.colFirst a:visited, td.colFirst a:hover, td.colLast a:link, td.colLast a:active, td.colLast a:visited, td.colLast a:hover, .constantValuesContainer td a:link, .constantValuesContainer td a:active, .constantValuesContainer td a:visited, .constantValuesContainer td a:hover {
font-weight:bold;
}
.tableSubHeadingColor {
background-color:#EEEEFF;
}
.altColor {
background-color:#FFFFFF;
}
.rowColor {
background-color:#EEEEEF;
}
/*
Content styles
*/
.description pre {
margin-top:0;
}
.deprecatedContent {
margin:0;
padding:10px 0;
}
.docSummary {
padding:0;
}
ul.blockList ul.blockList ul.blockList li.blockList h3 {
font-style:normal;
}
div.block {
font-size:14px;
font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif;
}
td.colLast div {
padding-top:0px;
}
td.colLast a {
padding-bottom:3px;
}
/*
Formatting effect styles
*/
.sourceLineNo {
color:green;
padding:0 30px 0 0;
}
h1.hidden {
visibility:hidden;
overflow:hidden;
font-size:10px;
}
.block {
display:block;
margin:3px 10px 2px 0px;
color:#474747;
}
.deprecatedLabel, .descfrmTypeLabel, .memberNameLabel, .memberNameLink,
.overrideSpecifyLabel, .packageHierarchyLabel, .paramLabel, .returnLabel,
.seeLabel, .simpleTagLabel, .throwsLabel, .typeNameLabel, .typeNameLink {
font-weight:bold;
}
.deprecationComment, .emphasizedPhrase, .interfaceName {
font-style:italic;
}
div.block div.block span.deprecationComment, div.block div.block span.emphasizedPhrase,
div.block div.block span.interfaceName {
font-style:normal;
}
div.contentContainer ul.blockList li.blockList h2{
padding-bottom:0px;
}
================================================
FILE: docs/guide/groovy/index.md
================================================
# Reactive Postgres Client
The Reactive Postgres Client is a client for Postgres with a straightforward API focusing on
scalability and low overhead.
The client is reactive and non blocking, allowing to handle many database connections with a single thread.
* Event driven
* Lightweight
* Built-in connection pooling
* Prepared queries caching
* Publish / subscribe using Postgres `NOTIFY/LISTEN`
* Batch and cursor
* Row streaming
* Command pipeling
* RxJava 1 and RxJava 2
* Direct memory to object without unnecessary copies
* Java 8 Date and Time
* SSL/TLS
* Unix domain socket
* HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy support
## Usage
To use the Reactive Postgres Client add the following dependency to the _dependencies_ section of your build descriptor:
* Maven (in your `pom.xml`):
```xml
io.reactiversereactive-pg-client0.11.4
```
* Gradle (in your `build.gradle` file):
```groovy
dependencies {
compile 'io.reactiverse:reactive-pg-client:0.11.4'
}
```
## Getting started
Here is the simplest way to connect, query and disconnect
```groovy
// Pool options
def options = [
port:5432,
host:"the-host",
database:"the-db",
user:"user",
password:"secret",
maxSize:5
]
// Create the client pool
def client = PgClient.pool(options)
// A simple query
client.query("SELECT * FROM users WHERE id='julien'", { ar ->
if (ar.succeeded()) {
def result = ar.result()
println("Got ${result.size()} rows ")
} else {
println("Failure: ${ar.cause().getMessage()}")
}
// Now close the pool
client.close()
})
```
## Connecting to Postgres
Most of the time you will use a pool to connect to Postgres:
```groovy
// Pool options
def options = [
port:5432,
host:"the-host",
database:"the-db",
user:"user",
password:"secret",
maxSize:5
]
// Create the pooled client
def client = PgClient.pool(options)
```
The pooled client uses a connection pool and any operation will borrow a connection from the pool
to execute the operation and release it to the pool.
If you are running with Vert.x you can pass it your Vertx instance:
```groovy
// Pool options
def options = [
port:5432,
host:"the-host",
database:"the-db",
user:"user",
password:"secret",
maxSize:5
]
// Create the pooled client
def client = PgClient.pool(vertx, options)
```
You need to release the pool when you don't need it anymore:
```groovy
// Close the pool and all the associated resources
pool.close()
```
When you need to execute several operations on the same connection, you need to use a client
[`connection`](../../apidocs/io/reactiverse/pgclient/PgConnection.html).
You can easily get one from the pool:
```groovy
// Pool options
def options = [
port:5432,
host:"the-host",
database:"the-db",
user:"user",
password:"secret",
maxSize:5
]
// Create the pooled client
def client = PgClient.pool(vertx, options)
// Get a connection from the pool
client.getConnection({ ar1 ->
if (ar1.succeeded()) {
println("Connected")
// Obtain our connection
def conn = ar1.result()
// All operations execute on the same connection
conn.query("SELECT * FROM users WHERE id='julien'", { ar2 ->
if (ar2.succeeded()) {
conn.query("SELECT * FROM users WHERE id='emad'", { ar3 ->
// Release the connection to the pool
conn.close()
})
} else {
// Release the connection to the pool
conn.close()
}
})
} else {
println("Could not connect: ${ar1.cause().getMessage()}")
}
})
```
Once you are done with the connection you must close it to release it to the pool, so it can be reused.
Sometimes you want to improve performance via Unix domain socket connection, we achieve this with Vert.x Native transports.
Make sure you have added the required `netty-transport-native` dependency in your classpath and enabled the Unix domain socket option.
```groovy
// Pool Options
// Socket file name will be /var/run/postgresql/.s.PGSQL.5432
def options = [
host:"/var/run/postgresql",
port:5432,
database:"the-db"
]
// Create the pooled client
def client = PgClient.pool(options)
// Create the pooled client with a vertx instance
// Make sure the vertx instance has enabled native transports
def client2 = PgClient.pool(vertx, options)
```
More information can be found in the [Vert.x documentation](https://vertx.io/docs/vertx-core/java/#_native_transports).
## Configuration
There are several options for you to configure the client.
Apart from configuring with a `PgPoolOptions` data object, We also provide you an alternative way to connect when you want to configure with a connection URI:
```groovy
// Connection URI
def connectionUri = "postgresql://dbuser:secretpassword@database.server.com:3211/mydb"
// Create the pool from the connection URI
def pool = PgClient.pool(connectionUri)
// Create the connection from the connection URI
PgClient.connect(vertx, connectionUri, { res ->
// Handling your connection
})
```
More information about connection string formats can be found in the [PostgreSQL Manuals](https://www.postgresql.org/docs/9.6/static/libpq-connect.html#LIBPQ-CONNSTRING).
You can also use environment variables to set default connection setting values, this is useful
when you want to avoid hard-coding database connection information. You can refer to the [official documentation](https://www.postgresql.org/docs/9.6/static/libpq-envars.html)
for more details. The following parameters are supported:
* `PGHOST`
* `PGHOSTADDR`
* `PGPORT`
* `PGDATABASE`
* `PGUSER`
* `PGPASSWORD`
* `PGSSLMODE`
If you don't specify a data object or a connection URI string to connect, environment variables will take precedence over them.
```
$ PGUSER=user \
PGHOST=the-host \
PGPASSWORD=secret \
PGDATABASE=the-db \
PGPORT=5432 \
PGSSLMODE=DISABLE
```
```groovy
// Create the pool from the environment variables
def pool = PgClient.pool()
// Create the connection from the environment variables
PgClient.connect(vertx, { res ->
// Handling your connection
})
```
## Running queries
When you don't need a transaction or run single queries, you can run queries directly on the pool; the pool
will use one of its connection to run the query and return the result to you.
Here is how to run simple queries:
```groovy
client.query("SELECT * FROM users WHERE id='julien'", { ar ->
if (ar.succeeded()) {
def result = ar.result()
println("Got ${result.size()} rows ")
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
You can do the same with prepared queries.
The SQL string can refer to parameters by position, using `$1`, `$2`, etc…
```groovy
client.preparedQuery("SELECT * FROM users WHERE id=$1", Tuple.of("julien"), { ar ->
if (ar.succeeded()) {
def rows = ar.result()
println("Got ${rows.size()} rows ")
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
Query methods provides an asynchronous [`PgRowSet`](../../apidocs/io/reactiverse/pgclient/PgRowSet.html) instance that works for _SELECT_ queries
```groovy
client.preparedQuery("SELECT first_name, last_name FROM users", { ar ->
if (ar.succeeded()) {
def rows = ar.result()
rows.each { row ->
println("User ${row.getString(0)} ${row.getString(1)}")
}
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
or _UPDATE_/_INSERT_ queries:
```groovy
client.preparedQuery("INSERT INTO users (first_name, last_name) VALUES ($1, $2)", Tuple.of("Julien", "Viet"), { ar ->
if (ar.succeeded()) {
def rows = ar.result()
println(rows.rowCount())
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
The [`Row`](../../apidocs/io/reactiverse/pgclient/Row.html) gives you access to your data by index
```groovy
println("User ${row.getString(0)} ${row.getString(1)}")
```
or by name
```groovy
println("User ${row.getString("first_name")} ${row.getString("last_name")}")
```
You can access a wide variety of of types
```groovy
def firstName = row.getString("first_name")
def male = row.getBoolean("male")
def age = row.getInteger("age")
// ...
```
You can execute prepared batch
```groovy
// Add commands to the batch
def batch = []
batch.add(Tuple.of("julien", "Julien Viet"))
batch.add(Tuple.of("emad", "Emad Alblueshi"))
// Execute the prepared batch
client.preparedBatch("INSERT INTO USERS (id, name) VALUES ($1, $2)", batch, { res ->
if (res.succeeded()) {
// Process rows
def rows = res.result()
} else {
println("Batch failed ${res.cause()}")
}
})
```
You can cache prepared queries:
```groovy
// Enable prepare statements
options.cachePreparedStatements = true
def client = PgClient.pool(vertx, options)
```
You can fetch generated keys with a 'RETURNING' clause in your query:
```groovy
client.preparedQuery("INSERT INTO color (color_name) VALUES ($1), ($2), ($3) RETURNING color_id", Tuple.of("white", "red", "blue"), { ar ->
if (ar.succeeded()) {
def rows = ar.result()
println(rows.rowCount())
rows.each { row ->
println("generated key: ${row.getInteger("color_id")}")
}
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
## Using connections
When you need to execute sequential queries (without a transaction), you can create a new connection
or borrow one from the pool:
```groovy
Code not translatable
```
Prepared queries can be created:
```groovy
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", { ar1 ->
if (ar1.succeeded()) {
def pq = ar1.result()
pq.execute(Tuple.of("julien"), { ar2 ->
if (ar2.succeeded()) {
// All rows
def rows = ar2.result()
}
})
}
})
```
NOTE: prepared query caching depends on the [`setCachePreparedStatements`](../../apidocs/io/reactiverse/pgclient/PgConnectOptions.html#setCachePreparedStatements-boolean-) and
does not depend on whether you are creating prepared queries or use [`direct prepared queries`](../../apidocs/io/reactiverse/pgclient/PgClient.html#preparedQuery-java.lang.String-io.vertx.core.Handler-)
[`PgPreparedQuery`](../../apidocs/io/reactiverse/pgclient/PgPreparedQuery.html)can perform efficient batching:
```groovy
connection.prepare("INSERT INTO USERS (id, name) VALUES ($1, $2)", { ar1 ->
if (ar1.succeeded()) {
def prepared = ar1.result()
// Create a query : bind parameters
def batch = []
// Add commands to the createBatch
batch.add(Tuple.of("julien", "Julien Viet"))
batch.add(Tuple.of("emad", "Emad Alblueshi"))
prepared.batch(batch, { res ->
if (res.succeeded()) {
// Process rows
def rows = res.result()
} else {
println("Batch failed ${res.cause()}")
}
})
}
})
```
## Using transactions
### Transactions with connections
You can execute transaction using SQL `BEGIN`/`COMMIT`/`ROLLBACK`, if you do so you must use
a [`PgConnection`](../../apidocs/io/reactiverse/pgclient/PgConnection.html) and manage it yourself.
Or you can use the transaction API of [`PgConnection`](../../apidocs/io/reactiverse/pgclient/PgConnection.html):
```groovy
Code not translatable
```
When Postgres reports the current transaction is failed (e.g the infamous _current transaction is aborted, commands ignored until
end of transaction block_), the transaction is rollbacked and the [`abortHandler`](../../apidocs/io/reactiverse/pgclient/PgTransaction.html#abortHandler-io.vertx.core.Handler-)
is called:
```groovy
pool.getConnection({ res ->
if (res.succeeded()) {
// Transaction must use a connection
def conn = res.result()
// Begin the transaction
def tx = conn.begin().abortHandler({ v ->
println("Transaction failed => rollbacked")
})
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", { ar ->
// Works fine of course
if (ar.succeeded()) {
} else {
tx.rollback()
conn.close()
}
})
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", { ar ->
// Fails and triggers transaction aborts
})
// Attempt to commit the transaction
tx.commit({ ar ->
// But transaction abortion fails it
// Return the connection to the pool
conn.close()
})
}
})
```
### Simplified transaction API
When you use a pool, you can start a transaction directly on the pool.
It borrows a connection from the pool, begins the transaction and releases the connection to the pool when the transaction ends.
```groovy
Code not translatable
```
## Cursors and streaming
By default prepared query execution fetches all rows, you can use a
[`PgCursor`](../../apidocs/io/reactiverse/pgclient/PgCursor.html)to control the amount of rows you want to read:
```groovy
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", { ar1 ->
if (ar1.succeeded()) {
def pq = ar1.result()
// Cursors require to run within a transaction
def tx = connection.begin()
// Create a cursor
def cursor = pq.cursor(Tuple.of("julien"))
// Read 50 rows
cursor.read(50, { ar2 ->
if (ar2.succeeded()) {
def rows = ar2.result()
// Check for more ?
if (cursor.hasMore()) {
// Repeat the process...
} else {
// No more rows - commit the transaction
tx.commit()
}
}
})
}
})
```
PostreSQL destroys cursors at the end of a transaction, so the cursor API shall be used
within a transaction, otherwise you will likely get the `34000` PostgreSQL error.
Cursors shall be closed when they are released prematurely:
```groovy
cursor.read(50, { ar2 ->
if (ar2.succeeded()) {
// Close the cursor
cursor.close()
}
})
```
A stream API is also available for cursors, which can be more convenient, specially with the Rxified version.
```groovy
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", { ar1 ->
if (ar1.succeeded()) {
def pq = ar1.result()
// Streams require to run within a transaction
def tx = connection.begin()
// Fetch 50 rows at a time
def stream = pq.createStream(50, Tuple.of("julien"))
// Use the stream
stream.exceptionHandler({ err ->
println("Error: ${err.getMessage()}")
})
stream.endHandler({ v ->
tx.commit()
println("End of stream")
})
stream.handler({ row ->
println("User: ${row.getString("last_name")}")
})
}
})
```
The stream read the rows by batch of `50` and stream them, when the rows have been passed to the handler,
a new batch of `50` is read and so on.
The stream can be resumed or paused, the loaded rows will remain in memory until they are delivered and the cursor
will stop iterating.
## Postgres type mapping
Currently the client supports the following Postgres types
* BOOLEAN (`java.lang.Boolean`)
* INT2 (`java.lang.Short`)
* INT4 (`java.lang.Integer`)
* INT8 (`java.lang.Long`)
* FLOAT4 (`java.lang.Float`)
* FLOAT8 (`java.lang.Double`)
* CHAR (`java.lang.String`)
* VARCHAR (`java.lang.String`)
* TEXT (`java.lang.String`)
* ENUM (`java.lang.String`)
* NAME (`java.lang.String`)
* SERIAL2 (`java.lang.Short`)
* SERIAL4 (`java.lang.Integer`)
* SERIAL8 (`java.lang.Long`)
* NUMERIC (`io.reactiverse.pgclient.data.Numeric`)
* UUID (`java.util.UUID`)
* DATE (`java.time.LocalDate`)
* TIME (`java.time.LocalTime`)
* TIMETZ (`java.time.OffsetTime`)
* TIMESTAMP (`java.time.LocalDateTime`)
* TIMESTAMPTZ (`java.time.OffsetDateTime`)
* INTERVAL (`io.reactiverse.pgclient.data.Interval`)
* BYTEA (`io.vertx.core.buffer.Buffer`)
* JSON (`io.reactiverse.pgclient.data.Json`)
* JSONB (`io.reactiverse.pgclient.data.Json`)
* POINT (`io.reactiverse.pgclient.data.Point`)
* LINE (`io.reactiverse.pgclient.data.Line`)
* LSEG (`io.reactiverse.pgclient.data.LineSegment`)
* BOX (`io.reactiverse.pgclient.data.Box`)
* PATH (`io.reactiverse.pgclient.data.Path`)
* POLYGON (`io.reactiverse.pgclient.data.Polygon`)
* CIRCLE (`io.reactiverse.pgclient.data.Circle`)
Tuple decoding uses the above types when storing values, it also performs on the flu conversion the actual value when possible:
```groovy
pool.query("SELECT 1::BIGINT \"VAL\"", { ar ->
def rowSet = ar.result()
def row = rowSet.iterator().next()
// Stored as java.lang.Long
def value = row.getValue(0)
// Convert to java.lang.Integer
def intValue = row.getInteger(0)
})
```
Tuple encoding uses the above type mapping for encoding, unless the type is numeric in which case `java.lang.Number` is used instead:
```groovy
pool.query("SELECT 1::BIGINT \"VAL\"", { ar ->
def rowSet = ar.result()
def row = rowSet.iterator().next()
// Stored as java.lang.Long
def value = row.getValue(0)
// Convert to java.lang.Integer
def intValue = row.getInteger(0)
})
```
Arrays of these types are supported.
### Handling JSON
The [`Json`](../../apidocs/io/reactiverse/pgclient/data/Json.html) Java type is used to represent the Postgres `JSON` and `JSONB` type.
The main reason of this type is handling `null` JSON values.
```groovy
// Create a tuple
def tuple = Tuple.of(Json.create(Json.create(null)), Json.create(Json.create([
foo:"bar"
])), Json.create(Json.create(null)))
// Retrieving json
def value = tuple.getJson(0).value()
//
value = tuple.getJson(1).value()
//
value = tuple.getJson(3).value()
```
### Handling NUMERIC
The [`Numeric`](../../apidocs/io/reactiverse/pgclient/data/Numeric.html) Java type is used to represent the Postgres `NUMERIC` type.
```groovy
def numeric = row.getNumeric("value")
if (numeric.isNaN()) {
// Handle NaN
} else {
def value = numeric.bigDecimalValue()
}
```
## Handling arrays
Arrays are available on [`Tuple`](../../apidocs/io/reactiverse/pgclient/Tuple.html) and [`Row`](../../apidocs/io/reactiverse/pgclient/Row.html):
```groovy
Code not translatable
```
## Handling custom types
Strings are used to represent custom types, both sent to and returned from Postgres.
You can read from Postgres and get the custom type as a string
```groovy
client.preparedQuery("SELECT address, (address).city FROM address_book WHERE id=$1", Tuple.of(3), { ar ->
if (ar.succeeded()) {
def rows = ar.result()
rows.each { row ->
println("Full Address ${row.getString(0)}, City ${row.getString(1)}")
}
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
You can also write to Postgres by providing a string
```groovy
client.preparedQuery("INSERT INTO address_book (id, address) VALUES ($1, $2)", Tuple.of(3, "('Anytown', 'Second Ave', false)"), { ar ->
if (ar.succeeded()) {
def rows = ar.result()
println(rows.rowCount())
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
## Collector queries
You can use Java collectors with the query API:
```groovy
Code not translatable
```
The collector processing must not keep a reference on the [`Row`](../../apidocs/io/reactiverse/pgclient/Row.html) as
there is a single row used for processing the entire set.
The Java `Collectors` provides many interesting predefined collectors, for example you can
create easily create a string directly from the row set:
```groovy
Code not translatable
```
## RxJava support
The rxified API supports RxJava 1 and RxJava 2, the following examples use RxJava 2.
Most asynchronous constructs are available as methods prefixed by `rx`:
```groovy
Code not translatable
```
### Streaming
RxJava 2 supports `Observable` and `Flowable` types, these are exposed using
the [`PgStream`](../../apidocs/io/reactiverse/reactivex/pgclient/PgStream.html) that you can get
from a [`PgPreparedQuery`](../../apidocs/io/reactiverse/reactivex/pgclient/PgPreparedQuery.html):
```groovy
Code not translatable
```
The same example using `Flowable`:
```groovy
Code not translatable
```
### Transaction
The simplified transaction API allows to easily write transactional
asynchronous flows:
```groovy
Code not translatable
```
## Pub/sub
Postgres supports pub/sub communication channels.
You can set a [`notificationHandler`](../../apidocs/io/reactiverse/pgclient/PgConnection.html#notificationHandler-io.vertx.core.Handler-) to receive
Postgres notifications:
```groovy
connection.notificationHandler({ notification ->
println("Received ${notification.payload} on channel ${notification.channel}")
})
connection.query("LISTEN some-channel", { ar ->
println("Subscribed to channel")
})
```
The [`PgSubscriber`](../../apidocs/io/reactiverse/pgclient/pubsub/PgSubscriber.html) is a channel manager managing a single connection that
provides per channel subscription:
```groovy
def subscriber = PgSubscriber.subscriber(vertx, [
port:5432,
host:"the-host",
database:"the-db",
user:"user",
password:"secret"
])
// You can set the channel before connect
subscriber.channel("channel1").handler({ payload ->
println("Received ${payload}")
})
subscriber.connect({ ar ->
if (ar.succeeded()) {
// Or you can set the channel after connect
subscriber.channel("channel2").handler({ payload ->
println("Received ${payload}")
})
}
})
```
The channel name that is given to the channel method will be the exact name of the channel as held by Postgres for sending
notifications. Note this is different than the representation of the channel name in SQL, and
internally [`PgSubscriber`](../../apidocs/io/reactiverse/pgclient/pubsub/PgSubscriber.html) will prepare the submitted channel name as a quoted identifier:
```groovy
def subscriber = PgSubscriber.subscriber(vertx, [
port:5432,
host:"the-host",
database:"the-db",
user:"user",
password:"secret"
])
subscriber.connect({ ar ->
if (ar.succeeded()) {
// Complex channel name - name in PostgreSQL requires a quoted ID
subscriber.channel("Complex.Channel.Name").handler({ payload ->
println("Received ${payload}")
})
subscriber.channel("Complex.Channel.Name").subscribeHandler({ subscribed ->
subscriber.actualConnection().query("NOTIFY \"Complex.Channel.Name\", 'msg'", { notified ->
println("Notified \"Complex.Channel.Name\"")
})
})
// PostgreSQL simple ID's are forced lower-case
subscriber.channel("simple_channel").handler({ payload ->
println("Received ${payload}")
})
subscriber.channel("simple_channel").subscribeHandler({ subscribed ->
// The following simple channel identifier is forced to lower case
subscriber.actualConnection().query("NOTIFY Simple_CHANNEL, 'msg'", { notified ->
println("Notified simple_channel")
})
})
// The following channel name is longer than the current
// (NAMEDATALEN = 64) - 1 == 63 character limit and will be truncated
subscriber.channel("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbb").handler({ payload ->
println("Received ${payload}")
})
}
})
```
You can provide a reconnect policy as a function that takes the number of `retries` as argument and returns an `amountOfTime`
value:
* when `amountOfTime < 0`: the subscriber is closed and there is no retry
* when `amountOfTime = 0`: the subscriber retries to connect immediately
* when `amountOfTime > 0`: the subscriber retries after `amountOfTime` milliseconds
```groovy
def subscriber = PgSubscriber.subscriber(vertx, [
port:5432,
host:"the-host",
database:"the-db",
user:"user",
password:"secret"
])
// Reconnect at most 10 times after 100 ms each
subscriber.reconnectPolicy({ retries ->
if (retries < 10) {
return 100L
} else {
return -1L
}
})
```
The default policy is to not reconnect.
## Cancelling Request
Postgres supports cancellation of requests in progress. You can cancel inflight requests using [`cancelRequest`](../../apidocs/io/reactiverse/pgclient/PgConnection.html#cancelRequest-io.vertx.core.Handler-). Cancelling a request opens a new connection to the server and cancels the request and then close the connection.
```groovy
connection.query("SELECT pg_sleep(20)", { ar ->
if (ar.succeeded()) {
// imagine this is a long query and is still running
println("Query success")
} else {
// the server will abort the current query after cancelling request
println("Failed to query due to ${ar.cause().getMessage()}")
}
})
connection.cancelRequest({ ar ->
if (ar.succeeded()) {
println("Cancelling request has been sent")
} else {
println("Failed to send cancelling request")
}
})
```
> The cancellation signal might or might not have any effect — for example, if it arrives after the backend has finished processing the query, then it will have no effect. If the cancellation is effective, it results in the current command being terminated early with an error message.
More information can be found in the [official documentation](https://www.postgresql.org/docs/11/protocol-flow.html#id-1.10.5.7.9).
## Using SSL/TLS
To configure the client to use SSL connection, you can configure the [`PgConnectOptions`](../../apidocs/io/reactiverse/pgclient/PgConnectOptions.html)
like a Vert.x `NetClient`.
All [SSL modes](https://www.postgresql.org/docs/current/libpq-ssl.html#LIBPQ-SSL-PROTECTION) are supported and you are able to configure `sslmode`. The client is in `DISABLE` SSL mode by default.
`ssl` parameter is kept as a mere shortcut for setting `sslmode`. `setSsl(true)` is equivalent to `setSslMode(VERIFY_CA)` and `setSsl(false)` is equivalent to `setSslMode(DISABLE)`.
```groovy
def options = [
port:5432,
host:"the-host",
database:"the-db",
user:"user",
password:"secret",
sslMode:"VERIFY_CA",
pemTrustOptions:[
certPaths:[
"/path/to/cert.pem"
]
]
]
PgClient.connect(vertx, options, { res ->
if (res.succeeded()) {
// Connected with SSL
} else {
println("Could not connect ${res.cause()}")
}
})
```
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#ssl).
## Using a proxy
You can also configure the client to use an HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy.
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#_using_a_proxy_for_client_connections).
================================================
FILE: docs/guide/java/index.md
================================================
# Reactive Postgres Client
The Reactive Postgres Client is a client for Postgres with a straightforward API focusing on
scalability and low overhead.
The client is reactive and non blocking, allowing to handle many database connections with a single thread.
* Event driven
* Lightweight
* Built-in connection pooling
* Prepared queries caching
* Publish / subscribe using Postgres `NOTIFY/LISTEN`
* Batch and cursor
* Row streaming
* Command pipeling
* RxJava 1 and RxJava 2
* Direct memory to object without unnecessary copies
* Java 8 Date and Time
* SSL/TLS
* Unix domain socket
* HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy support
## Usage
To use the Reactive Postgres Client add the following dependency to the _dependencies_ section of your build descriptor:
* Maven (in your `pom.xml`):
```xml
io.reactiversereactive-pg-client0.11.4
```
* Gradle (in your `build.gradle` file):
```groovy
dependencies {
compile 'io.reactiverse:reactive-pg-client:0.11.4'
}
```
## Getting started
Here is the simplest way to connect, query and disconnect
```java
PgPoolOptions options = new PgPoolOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
.setMaxSize(5);
// Create the client pool
PgPool client = PgClient.pool(options);
// A simple query
client.query("SELECT * FROM users WHERE id='julien'", ar -> {
if (ar.succeeded()) {
PgRowSet result = ar.result();
System.out.println("Got " + result.size() + " rows ");
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
// Now close the pool
client.close();
});
```
## Connecting to Postgres
Most of the time you will use a pool to connect to Postgres:
```java
PgPoolOptions options = new PgPoolOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
.setMaxSize(5);
// Create the pooled client
PgPool client = PgClient.pool(options);
```
The pooled client uses a connection pool and any operation will borrow a connection from the pool
to execute the operation and release it to the pool.
If you are running with Vert.x you can pass it your Vertx instance:
```java
PgPoolOptions options = new PgPoolOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
.setMaxSize(5);
// Create the pooled client
PgPool client = PgClient.pool(vertx, options);
```
You need to release the pool when you don't need it anymore:
```java
pool.close();
```
When you need to execute several operations on the same connection, you need to use a client
[`connection`](../../apidocs/io/reactiverse/pgclient/PgConnection.html).
You can easily get one from the pool:
```java
PgPoolOptions options = new PgPoolOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
.setMaxSize(5);
// Create the pooled client
PgPool client = PgClient.pool(vertx, options);
// Get a connection from the pool
client.getConnection(ar1 -> {
if (ar1.succeeded()) {
System.out.println("Connected");
// Obtain our connection
PgConnection conn = ar1.result();
// All operations execute on the same connection
conn.query("SELECT * FROM users WHERE id='julien'", ar2 -> {
if (ar2.succeeded()) {
conn.query("SELECT * FROM users WHERE id='emad'", ar3 -> {
// Release the connection to the pool
conn.close();
});
} else {
// Release the connection to the pool
conn.close();
}
});
} else {
System.out.println("Could not connect: " + ar1.cause().getMessage());
}
});
```
Once you are done with the connection you must close it to release it to the pool, so it can be reused.
Sometimes you want to improve performance via Unix domain socket connection, we achieve this with Vert.x Native transports.
Make sure you have added the required `netty-transport-native` dependency in your classpath and enabled the Unix domain socket option.
```java
PgPoolOptions options = new PgPoolOptions()
.setHost("/var/run/postgresql")
.setPort(5432)
.setDatabase("the-db");
// Create the pooled client
PgPool client = PgClient.pool(options);
// Create the pooled client with a vertx instance
// Make sure the vertx instance has enabled native transports
PgPool client2 = PgClient.pool(vertx, options);
```
More information can be found in the [Vert.x documentation](https://vertx.io/docs/vertx-core/java/#_native_transports).
## Configuration
There are several options for you to configure the client.
Apart from configuring with a `PgPoolOptions` data object, We also provide you an alternative way to connect when you want to configure with a connection URI:
```java
String connectionUri = "postgresql://dbuser:secretpassword@database.server.com:3211/mydb";
// Create the pool from the connection URI
PgPool pool = PgClient.pool(connectionUri);
// Create the connection from the connection URI
PgClient.connect(vertx, connectionUri, res -> {
// Handling your connection
});
```
More information about connection string formats can be found in the [PostgreSQL Manuals](https://www.postgresql.org/docs/9.6/static/libpq-connect.html#LIBPQ-CONNSTRING).
You can also use environment variables to set default connection setting values, this is useful
when you want to avoid hard-coding database connection information. You can refer to the [official documentation](https://www.postgresql.org/docs/9.6/static/libpq-envars.html)
for more details. The following parameters are supported:
* `PGHOST`
* `PGHOSTADDR`
* `PGPORT`
* `PGDATABASE`
* `PGUSER`
* `PGPASSWORD`
* `PGSSLMODE`
If you don't specify a data object or a connection URI string to connect, environment variables will take precedence over them.
```
$ PGUSER=user \
PGHOST=the-host \
PGPASSWORD=secret \
PGDATABASE=the-db \
PGPORT=5432 \
PGSSLMODE=DISABLE
```
```java
PgPool pool = PgClient.pool();
// Create the connection from the environment variables
PgClient.connect(vertx, res -> {
// Handling your connection
});
```
## Running queries
When you don't need a transaction or run single queries, you can run queries directly on the pool; the pool
will use one of its connection to run the query and return the result to you.
Here is how to run simple queries:
```java
client.query("SELECT * FROM users WHERE id='julien'", ar -> {
if (ar.succeeded()) {
PgRowSet result = ar.result();
System.out.println("Got " + result.size() + " rows ");
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
});
```
You can do the same with prepared queries.
The SQL string can refer to parameters by position, using `$1`, `$2`, etc…
```java
client.preparedQuery("SELECT * FROM users WHERE id=$1", Tuple.of("julien"), ar -> {
if (ar.succeeded()) {
PgRowSet rows = ar.result();
System.out.println("Got " + rows.size() + " rows ");
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
});
```
Query methods provides an asynchronous [`PgRowSet`](../../apidocs/io/reactiverse/pgclient/PgRowSet.html) instance that works for _SELECT_ queries
```java
client.preparedQuery("SELECT first_name, last_name FROM users", ar -> {
if (ar.succeeded()) {
PgRowSet rows = ar.result();
for (Row row : rows) {
System.out.println("User " + row.getString(0) + " " + row.getString(1));
}
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
});
```
or _UPDATE_/_INSERT_ queries:
```java
client.preparedQuery("INSERT INTO users (first_name, last_name) VALUES ($1, $2)", Tuple.of("Julien", "Viet"), ar -> {
if (ar.succeeded()) {
PgRowSet rows = ar.result();
System.out.println(rows.rowCount());
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
});
```
The [`Row`](../../apidocs/io/reactiverse/pgclient/Row.html) gives you access to your data by index
```java
System.out.println("User " + row.getString(0) + " " + row.getString(1));
```
or by name
```java
System.out.println("User " + row.getString("first_name") + " " + row.getString("last_name"));
```
You can access a wide variety of of types
```java
String firstName = row.getString("first_name");
Boolean male = row.getBoolean("male");
Integer age = row.getInteger("age");
```
You can execute prepared batch
```java
List batch = new ArrayList<>();
batch.add(Tuple.of("julien", "Julien Viet"));
batch.add(Tuple.of("emad", "Emad Alblueshi"));
// Execute the prepared batch
client.preparedBatch("INSERT INTO USERS (id, name) VALUES ($1, $2)", batch, res -> {
if (res.succeeded()) {
// Process rows
PgRowSet rows = res.result();
} else {
System.out.println("Batch failed " + res.cause());
}
});
```
You can cache prepared queries:
```java
options.setCachePreparedStatements(true);
PgPool client = PgClient.pool(vertx, options);
```
You can fetch generated keys with a 'RETURNING' clause in your query:
```java
client.preparedQuery("INSERT INTO color (color_name) VALUES ($1), ($2), ($3) RETURNING color_id", Tuple.of("white", "red", "blue"), ar -> {
if (ar.succeeded()) {
PgRowSet rows = ar.result();
System.out.println(rows.rowCount());
for (Row row : rows) {
System.out.println("generated key: " + row.getInteger("color_id"));
}
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
});
```
## Using connections
When you need to execute sequential queries (without a transaction), you can create a new connection
or borrow one from the pool:
```java
pool.getConnection(ar1 -> {
if (ar1.succeeded()) {
PgConnection connection = ar1.result();
connection.query("SELECT * FROM users WHERE id='julien'", ar2 -> {
if (ar1.succeeded()) {
connection.query("SELECT * FROM users WHERE id='paulo'", ar3 -> {
// Do something with rows and return the connection to the pool
connection.close();
});
} else {
// Return the connection to the pool
connection.close();
}
});
}
});
```
Prepared queries can be created:
```java
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", ar1 -> {
if (ar1.succeeded()) {
PgPreparedQuery pq = ar1.result();
pq.execute(Tuple.of("julien"), ar2 -> {
if (ar2.succeeded()) {
// All rows
PgRowSet rows = ar2.result();
}
});
}
});
```
NOTE: prepared query caching depends on the [`setCachePreparedStatements`](../../apidocs/io/reactiverse/pgclient/PgConnectOptions.html#setCachePreparedStatements-boolean-) and
does not depend on whether you are creating prepared queries or use [`direct prepared queries`](../../apidocs/io/reactiverse/pgclient/PgClient.html#preparedQuery-java.lang.String-io.vertx.core.Handler-)
[`PgPreparedQuery`](../../apidocs/io/reactiverse/pgclient/PgPreparedQuery.html)can perform efficient batching:
```java
connection.prepare("INSERT INTO USERS (id, name) VALUES ($1, $2)", ar1 -> {
if (ar1.succeeded()) {
PgPreparedQuery prepared = ar1.result();
// Create a query : bind parameters
List batch = new ArrayList();
// Add commands to the createBatch
batch.add(Tuple.of("julien", "Julien Viet"));
batch.add(Tuple.of("emad", "Emad Alblueshi"));
prepared.batch(batch, res -> {
if (res.succeeded()) {
// Process rows
PgRowSet rows = res.result();
} else {
System.out.println("Batch failed " + res.cause());
}
});
}
});
```
## Using transactions
### Transactions with connections
You can execute transaction using SQL `BEGIN`/`COMMIT`/`ROLLBACK`, if you do so you must use
a [`PgConnection`](../../apidocs/io/reactiverse/pgclient/PgConnection.html) and manage it yourself.
Or you can use the transaction API of [`PgConnection`](../../apidocs/io/reactiverse/pgclient/PgConnection.html):
```java
pool.getConnection(res -> {
if (res.succeeded()) {
// Transaction must use a connection
PgConnection conn = res.result();
// Begin the transaction
PgTransaction tx = conn.begin();
// Various statements
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", ar -> {});
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Emad','Alblueshi')", ar -> {});
// Commit the transaction
tx.commit(ar -> {
if (ar.succeeded()) {
System.out.println("Transaction succeeded");
} else {
System.out.println("Transaction failed " + ar.cause().getMessage());
}
// Return the connection to the pool
conn.close();
});
}
});
```
When Postgres reports the current transaction is failed (e.g the infamous _current transaction is aborted, commands ignored until
end of transaction block_), the transaction is rollbacked and the [`abortHandler`](../../apidocs/io/reactiverse/pgclient/PgTransaction.html#abortHandler-io.vertx.core.Handler-)
is called:
```java
pool.getConnection(res -> {
if (res.succeeded()) {
// Transaction must use a connection
PgConnection conn = res.result();
// Begin the transaction
PgTransaction tx = conn
.begin()
.abortHandler(v -> {
System.out.println("Transaction failed => rollbacked");
});
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", ar -> {
// Works fine of course
if (ar.succeeded()) {
} else {
tx.rollback();
conn.close();
}
});
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", ar -> {
// Fails and triggers transaction aborts
});
// Attempt to commit the transaction
tx.commit(ar -> {
// But transaction abortion fails it
// Return the connection to the pool
conn.close();
});
}
});
```
### Simplified transaction API
When you use a pool, you can start a transaction directly on the pool.
It borrows a connection from the pool, begins the transaction and releases the connection to the pool when the transaction ends.
```java
pool.begin(res -> {
if (res.succeeded()) {
// Get the transaction
PgTransaction tx = res.result();
// Various statements
tx.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", ar -> {});
tx.query("INSERT INTO Users (first_name,last_name) VALUES ('Emad','Alblueshi')", ar -> {});
// Commit the transaction and return the connection to the pool
tx.commit(ar -> {
if (ar.succeeded()) {
System.out.println("Transaction succeeded");
} else {
System.out.println("Transaction failed " + ar.cause().getMessage());
}
});
}
});
```
## Cursors and streaming
By default prepared query execution fetches all rows, you can use a
[`PgCursor`](../../apidocs/io/reactiverse/pgclient/PgCursor.html)to control the amount of rows you want to read:
```java
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", ar1 -> {
if (ar1.succeeded()) {
PgPreparedQuery pq = ar1.result();
// Cursors require to run within a transaction
PgTransaction tx = connection.begin();
// Create a cursor
PgCursor cursor = pq.cursor(Tuple.of("julien"));
// Read 50 rows
cursor.read(50, ar2 -> {
if (ar2.succeeded()) {
PgRowSet rows = ar2.result();
// Check for more ?
if (cursor.hasMore()) {
// Repeat the process...
} else {
// No more rows - commit the transaction
tx.commit();
}
}
});
}
});
```
PostreSQL destroys cursors at the end of a transaction, so the cursor API shall be used
within a transaction, otherwise you will likely get the `34000` PostgreSQL error.
Cursors shall be closed when they are released prematurely:
```java
cursor.read(50, ar2 -> {
if (ar2.succeeded()) {
// Close the cursor
cursor.close();
}
});
```
A stream API is also available for cursors, which can be more convenient, specially with the Rxified version.
```java
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", ar1 -> {
if (ar1.succeeded()) {
PgPreparedQuery pq = ar1.result();
// Streams require to run within a transaction
PgTransaction tx = connection.begin();
// Fetch 50 rows at a time
PgStream stream = pq.createStream(50, Tuple.of("julien"));
// Use the stream
stream.exceptionHandler(err -> {
System.out.println("Error: " + err.getMessage());
});
stream.endHandler(v -> {
tx.commit();
System.out.println("End of stream");
});
stream.handler(row -> {
System.out.println("User: " + row.getString("last_name"));
});
}
});
```
The stream read the rows by batch of `50` and stream them, when the rows have been passed to the handler,
a new batch of `50` is read and so on.
The stream can be resumed or paused, the loaded rows will remain in memory until they are delivered and the cursor
will stop iterating.
## Postgres type mapping
Currently the client supports the following Postgres types
* BOOLEAN (`java.lang.Boolean`)
* INT2 (`java.lang.Short`)
* INT4 (`java.lang.Integer`)
* INT8 (`java.lang.Long`)
* FLOAT4 (`java.lang.Float`)
* FLOAT8 (`java.lang.Double`)
* CHAR (`java.lang.String`)
* VARCHAR (`java.lang.String`)
* TEXT (`java.lang.String`)
* ENUM (`java.lang.String`)
* NAME (`java.lang.String`)
* SERIAL2 (`java.lang.Short`)
* SERIAL4 (`java.lang.Integer`)
* SERIAL8 (`java.lang.Long`)
* NUMERIC (`io.reactiverse.pgclient.data.Numeric`)
* UUID (`java.util.UUID`)
* DATE (`java.time.LocalDate`)
* TIME (`java.time.LocalTime`)
* TIMETZ (`java.time.OffsetTime`)
* TIMESTAMP (`java.time.LocalDateTime`)
* TIMESTAMPTZ (`java.time.OffsetDateTime`)
* INTERVAL (`io.reactiverse.pgclient.data.Interval`)
* BYTEA (`io.vertx.core.buffer.Buffer`)
* JSON (`io.reactiverse.pgclient.data.Json`)
* JSONB (`io.reactiverse.pgclient.data.Json`)
* POINT (`io.reactiverse.pgclient.data.Point`)
* LINE (`io.reactiverse.pgclient.data.Line`)
* LSEG (`io.reactiverse.pgclient.data.LineSegment`)
* BOX (`io.reactiverse.pgclient.data.Box`)
* PATH (`io.reactiverse.pgclient.data.Path`)
* POLYGON (`io.reactiverse.pgclient.data.Polygon`)
* CIRCLE (`io.reactiverse.pgclient.data.Circle`)
Tuple decoding uses the above types when storing values, it also performs on the flu conversion the actual value when possible:
```java
pool.query("SELECT 1::BIGINT \"VAL\"", ar -> {
PgRowSet rowSet = ar.result();
Row row = rowSet.iterator().next();
// Stored as java.lang.Long
Object value = row.getValue(0);
// Convert to java.lang.Integer
Integer intValue = row.getInteger(0);
});
```
Tuple encoding uses the above type mapping for encoding, unless the type is numeric in which case `java.lang.Number` is used instead:
```java
pool.query("SELECT 1::BIGINT \"VAL\"", ar -> {
PgRowSet rowSet = ar.result();
Row row = rowSet.iterator().next();
// Stored as java.lang.Long
Object value = row.getValue(0);
// Convert to java.lang.Integer
Integer intValue = row.getInteger(0);
});
```
Arrays of these types are supported.
### Handling JSON
The [`Json`](../../apidocs/io/reactiverse/pgclient/data/Json.html) Java type is used to represent the Postgres `JSON` and `JSONB` type.
The main reason of this type is handling `null` JSON values.
```java
Tuple tuple = Tuple.of(
Json.create(Json.create(null)),
Json.create(Json.create(new JsonObject().put("foo", "bar"))),
Json.create(Json.create(null)));
// Retrieving json
Object value = tuple.getJson(0).value(); // Expect null
//
value = tuple.getJson(1).value(); // Expect JSON object
//
value = tuple.getJson(3).value(); // Expect 3
```
### Handling NUMERIC
The [`Numeric`](../../apidocs/io/reactiverse/pgclient/data/Numeric.html) Java type is used to represent the Postgres `NUMERIC` type.
```java
Numeric numeric = row.getNumeric("value");
if (numeric.isNaN()) {
// Handle NaN
} else {
BigDecimal value = numeric.bigDecimalValue();
}
```
## Handling arrays
Arrays are available on [`Tuple`](../../apidocs/io/reactiverse/pgclient/Tuple.html) and [`Row`](../../apidocs/io/reactiverse/pgclient/Row.html):
```java
Tuple tuple = Tuple.of(new String[]{ "a", "tuple", "with", "arrays" });
// Add a string array to the tuple
tuple.addStringArray(new String[]{"another", "array"});
// Get the first array of string
String[] array = tuple.getStringArray(0);
```
## Handling custom types
Strings are used to represent custom types, both sent to and returned from Postgres.
You can read from Postgres and get the custom type as a string
```java
client.preparedQuery("SELECT address, (address).city FROM address_book WHERE id=$1", Tuple.of(3), ar -> {
if (ar.succeeded()) {
PgRowSet rows = ar.result();
for (Row row : rows) {
System.out.println("Full Address " + row.getString(0) + ", City " + row.getString(1));
}
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
});
```
You can also write to Postgres by providing a string
```java
client.preparedQuery("INSERT INTO address_book (id, address) VALUES ($1, $2)", Tuple.of(3, "('Anytown', 'Second Ave', false)"), ar -> {
if (ar.succeeded()) {
PgRowSet rows = ar.result();
System.out.println(rows.rowCount());
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
});
```
## Collector queries
You can use Java collectors with the query API:
```java
Collector> collector = Collectors.toMap(
row -> row.getLong("id"),
row -> row.getString("last_name"));
// Run the query with the collector
client.query("SELECT * FROM users",
collector,
ar -> {
if (ar.succeeded()) {
PgResult> result = ar.result();
// Get the map created by the collector
Map map = result.value();
System.out.println("Got " + map);
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
});
```
The collector processing must not keep a reference on the [`Row`](../../apidocs/io/reactiverse/pgclient/Row.html) as
there is a single row used for processing the entire set.
The Java `Collectors` provides many interesting predefined collectors, for example you can
create easily create a string directly from the row set:
```java
Collector collector = Collectors.mapping(
row -> row.getString("last_name"),
Collectors.joining(",", "(", ")")
);
// Run the query with the collector
client.query("SELECT * FROM users",
collector,
ar -> {
if (ar.succeeded()) {
PgResult result = ar.result();
// Get the string created by the collector
String list = result.value();
System.out.println("Got " + list);
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
});
```
## RxJava support
The rxified API supports RxJava 1 and RxJava 2, the following examples use RxJava 2.
Most asynchronous constructs are available as methods prefixed by `rx`:
```java
Single single = pool.rxQuery("SELECT * FROM users WHERE id='julien'");
// Execute the query
single.subscribe(result -> {
System.out.println("Got " + result.size() + " rows ");
}, err -> {
System.out.println("Failure: " + err.getMessage());
});
```
### Streaming
RxJava 2 supports `Observable` and `Flowable` types, these are exposed using
the [`PgStream`](../../apidocs/io/reactiverse/reactivex/pgclient/PgStream.html) that you can get
from a [`PgPreparedQuery`](../../apidocs/io/reactiverse/reactivex/pgclient/PgPreparedQuery.html):
```java
Observable observable = pool.rxBegin() // Cursors require a transaction
.flatMapObservable(tx -> tx
.rxPrepare("SELECT * FROM users WHERE first_name LIKE $1")
.flatMapObservable(preparedQuery -> {
// Fetch 50 rows at a time
PgStream stream = preparedQuery.createStream(50, Tuple.of("julien"));
return stream.toObservable();
})
// Commit the transaction after usage
.doAfterTerminate(tx::commit));
// Then subscribe
observable.subscribe(row -> {
System.out.println("User: " + row.getString("last_name"));
}, err -> {
System.out.println("Error: " + err.getMessage());
}, () -> {
System.out.println("End of stream");
});
```
The same example using `Flowable`:
```java
Flowable flowable = pool.rxBegin() // Cursors require a transaction
.flatMapPublisher(tx -> tx.rxPrepare("SELECT * FROM users WHERE first_name LIKE $1")
.flatMapPublisher(preparedQuery -> {
// Fetch 50 rows at a time
PgStream stream = preparedQuery.createStream(50, Tuple.of("julien"));
return stream.toFlowable();
})
// Commit the transaction after usage
.doAfterTerminate(tx::commit));
// Then subscribe
flowable.subscribe(new Subscriber() {
private Subscription sub;
@Override
public void onSubscribe(Subscription subscription) {
sub = subscription;
subscription.request(1);
}
@Override
public void onNext(Row row) {
sub.request(1);
System.out.println("User: " + row.getString("last_name"));
}
@Override
public void onError(Throwable err) {
System.out.println("Error: " + err.getMessage());
}
@Override
public void onComplete() {
System.out.println("End of stream");
}
});
```
### Transaction
The simplified transaction API allows to easily write transactional
asynchronous flows:
```java
Completable completable = pool
.rxBegin()
.flatMapCompletable(tx -> tx
.rxQuery("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')")
.flatMap(result -> tx.rxQuery("INSERT INTO Users (first_name,last_name) VALUES ('Emad','Alblueshi')"))
.flatMapCompletable(result -> tx.rxCommit()));
completable.subscribe(() -> {
// Transaction succeeded
}, err -> {
// Transaction failed
});
```
## Pub/sub
Postgres supports pub/sub communication channels.
You can set a [`notificationHandler`](../../apidocs/io/reactiverse/pgclient/PgConnection.html#notificationHandler-io.vertx.core.Handler-) to receive
Postgres notifications:
```java
connection.notificationHandler(notification -> {
System.out.println("Received " + notification.getPayload() + " on channel " + notification.getChannel());
});
connection.query("LISTEN some-channel", ar -> {
System.out.println("Subscribed to channel");
});
```
The [`PgSubscriber`](../../apidocs/io/reactiverse/pgclient/pubsub/PgSubscriber.html) is a channel manager managing a single connection that
provides per channel subscription:
```java
PgSubscriber subscriber = PgSubscriber.subscriber(vertx, new PgConnectOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
);
// You can set the channel before connect
subscriber.channel("channel1").handler(payload -> {
System.out.println("Received " + payload);
});
subscriber.connect(ar -> {
if (ar.succeeded()) {
// Or you can set the channel after connect
subscriber.channel("channel2").handler(payload -> {
System.out.println("Received " + payload);
});
}
});
```
The channel name that is given to the channel method will be the exact name of the channel as held by Postgres for sending
notifications. Note this is different than the representation of the channel name in SQL, and
internally [`PgSubscriber`](../../apidocs/io/reactiverse/pgclient/pubsub/PgSubscriber.html) will prepare the submitted channel name as a quoted identifier:
```java
PgSubscriber subscriber = PgSubscriber.subscriber(vertx, new PgConnectOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
);
subscriber.connect(ar -> {
if (ar.succeeded()) {
// Complex channel name - name in PostgreSQL requires a quoted ID
subscriber.channel("Complex.Channel.Name").handler(payload -> {
System.out.println("Received " + payload);
});
subscriber.channel("Complex.Channel.Name").subscribeHandler(subscribed -> {
subscriber.actualConnection().query(
"NOTIFY \"Complex.Channel.Name\", 'msg'", notified -> {
System.out.println("Notified \"Complex.Channel.Name\"");
});
});
// PostgreSQL simple ID's are forced lower-case
subscriber.channel("simple_channel").handler(payload -> {
System.out.println("Received " + payload);
});
subscriber.channel("simple_channel").subscribeHandler(subscribed -> {
// The following simple channel identifier is forced to lower case
subscriber.actualConnection().query(
"NOTIFY Simple_CHANNEL, 'msg'", notified -> {
System.out.println("Notified simple_channel");
});
});
// The following channel name is longer than the current
// (NAMEDATALEN = 64) - 1 == 63 character limit and will be truncated
subscriber.channel(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbb"
).handler(payload -> {
System.out.println("Received " + payload);
});
}
});
```
You can provide a reconnect policy as a function that takes the number of `retries` as argument and returns an `amountOfTime`
value:
* when `amountOfTime < 0`: the subscriber is closed and there is no retry
* when `amountOfTime = 0`: the subscriber retries to connect immediately
* when `amountOfTime > 0`: the subscriber retries after `amountOfTime` milliseconds
```java
PgSubscriber subscriber = PgSubscriber.subscriber(vertx, new PgConnectOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
);
// Reconnect at most 10 times after 100 ms each
subscriber.reconnectPolicy(retries -> {
if (retries < 10) {
return 100L;
} else {
return -1L;
}
});
```
The default policy is to not reconnect.
## Cancelling Request
Postgres supports cancellation of requests in progress. You can cancel inflight requests using [`cancelRequest`](../../apidocs/io/reactiverse/pgclient/PgConnection.html#cancelRequest-io.vertx.core.Handler-). Cancelling a request opens a new connection to the server and cancels the request and then close the connection.
```java
connection.query("SELECT pg_sleep(20)", ar -> {
if (ar.succeeded()) {
// imagine this is a long query and is still running
System.out.println("Query success");
} else {
// the server will abort the current query after cancelling request
System.out.println("Failed to query due to " + ar.cause().getMessage());
}
});
connection.cancelRequest(ar -> {
if (ar.succeeded()) {
System.out.println("Cancelling request has been sent");
} else {
System.out.println("Failed to send cancelling request");
}
});
```
> The cancellation signal might or might not have any effect — for example, if it arrives after the backend has finished processing the query, then it will have no effect. If the cancellation is effective, it results in the current command being terminated early with an error message.
More information can be found in the [official documentation](https://www.postgresql.org/docs/11/protocol-flow.html#id-1.10.5.7.9).
## Using SSL/TLS
To configure the client to use SSL connection, you can configure the [`PgConnectOptions`](../../apidocs/io/reactiverse/pgclient/PgConnectOptions.html)
like a Vert.x `NetClient`.
All [SSL modes](https://www.postgresql.org/docs/current/libpq-ssl.html#LIBPQ-SSL-PROTECTION) are supported and you are able to configure `sslmode`. The client is in `DISABLE` SSL mode by default.
`ssl` parameter is kept as a mere shortcut for setting `sslmode`. `setSsl(true)` is equivalent to `setSslMode(VERIFY_CA)` and `setSsl(false)` is equivalent to `setSslMode(DISABLE)`.
```java
PgConnectOptions options = new PgConnectOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
.setSslMode(SslMode.VERIFY_CA)
.setPemTrustOptions(new PemTrustOptions().addCertPath("/path/to/cert.pem"));
PgClient.connect(vertx, options, res -> {
if (res.succeeded()) {
// Connected with SSL
} else {
System.out.println("Could not connect " + res.cause());
}
});
```
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#ssl).
## Using a proxy
You can also configure the client to use an HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy.
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#_using_a_proxy_for_client_connections).
================================================
FILE: docs/guide/js/index.md
================================================
# Reactive Postgres Client
The Reactive Postgres Client is a client for Postgres with a straightforward API focusing on
scalability and low overhead.
The client is reactive and non blocking, allowing to handle many database connections with a single thread.
* Event driven
* Lightweight
* Built-in connection pooling
* Prepared queries caching
* Publish / subscribe using Postgres `NOTIFY/LISTEN`
* Batch and cursor
* Row streaming
* Command pipeling
* RxJava 1 and RxJava 2
* Direct memory to object without unnecessary copies
* Java 8 Date and Time
* SSL/TLS
* Unix domain socket
* HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy support
## Usage
To use the Reactive Postgres Client add the following dependency to the _dependencies_ section of your build descriptor:
* Maven (in your `pom.xml`):
```xml
io.reactiversereactive-pg-client0.11.4
```
* Gradle (in your `build.gradle` file):
```groovy
dependencies {
compile 'io.reactiverse:reactive-pg-client:0.11.4'
}
```
## Getting started
Here is the simplest way to connect, query and disconnect
```js
var PgClient = require("reactive-pg-client-js/pg_client");
// Pool options
var options = {
"port" : 5432,
"host" : "the-host",
"database" : "the-db",
"user" : "user",
"password" : "secret",
"maxSize" : 5
};
// Create the client pool
var client = PgClient.pool(options);
// A simple query
client.query("SELECT * FROM users WHERE id='julien'", function (ar, ar_err) {
if (ar_err == null) {
var result = ar;
console.log("Got " + result.size() + " rows ");
} else {
console.log("Failure: " + ar_err.getMessage());
}
// Now close the pool
client.close();
});
```
## Connecting to Postgres
Most of the time you will use a pool to connect to Postgres:
```js
var PgClient = require("reactive-pg-client-js/pg_client");
// Pool options
var options = {
"port" : 5432,
"host" : "the-host",
"database" : "the-db",
"user" : "user",
"password" : "secret",
"maxSize" : 5
};
// Create the pooled client
var client = PgClient.pool(options);
```
The pooled client uses a connection pool and any operation will borrow a connection from the pool
to execute the operation and release it to the pool.
If you are running with Vert.x you can pass it your Vertx instance:
```js
var PgClient = require("reactive-pg-client-js/pg_client");
// Pool options
var options = {
"port" : 5432,
"host" : "the-host",
"database" : "the-db",
"user" : "user",
"password" : "secret",
"maxSize" : 5
};
// Create the pooled client
var client = PgClient.pool(vertx, options);
```
You need to release the pool when you don't need it anymore:
```js
// Close the pool and all the associated resources
pool.close();
```
When you need to execute several operations on the same connection, you need to use a client
[`connection`](../../jsdoc/module-reactive-pg-client-js_pg_connection-PgConnection.html).
You can easily get one from the pool:
```js
var PgClient = require("reactive-pg-client-js/pg_client");
// Pool options
var options = {
"port" : 5432,
"host" : "the-host",
"database" : "the-db",
"user" : "user",
"password" : "secret",
"maxSize" : 5
};
// Create the pooled client
var client = PgClient.pool(vertx, options);
// Get a connection from the pool
client.getConnection(function (ar1, ar1_err) {
if (ar1_err == null) {
console.log("Connected");
// Obtain our connection
var conn = ar1;
// All operations execute on the same connection
conn.query("SELECT * FROM users WHERE id='julien'", function (ar2, ar2_err) {
if (ar2_err == null) {
conn.query("SELECT * FROM users WHERE id='emad'", function (ar3, ar3_err) {
// Release the connection to the pool
conn.close();
});
} else {
// Release the connection to the pool
conn.close();
}
});
} else {
console.log("Could not connect: " + ar1_err.getMessage());
}
});
```
Once you are done with the connection you must close it to release it to the pool, so it can be reused.
Sometimes you want to improve performance via Unix domain socket connection, we achieve this with Vert.x Native transports.
Make sure you have added the required `netty-transport-native` dependency in your classpath and enabled the Unix domain socket option.
```js
var PgClient = require("reactive-pg-client-js/pg_client");
// Pool Options
// Socket file name will be /var/run/postgresql/.s.PGSQL.5432
var options = {
"host" : "/var/run/postgresql",
"port" : 5432,
"database" : "the-db"
};
// Create the pooled client
var client = PgClient.pool(options);
// Create the pooled client with a vertx instance
// Make sure the vertx instance has enabled native transports
var client2 = PgClient.pool(vertx, options);
```
More information can be found in the [Vert.x documentation](https://vertx.io/docs/vertx-core/java/#_native_transports).
## Configuration
There are several options for you to configure the client.
Apart from configuring with a `PgPoolOptions` data object, We also provide you an alternative way to connect when you want to configure with a connection URI:
```js
var PgClient = require("reactive-pg-client-js/pg_client");
// Connection URI
var connectionUri = "postgresql://dbuser:secretpassword@database.server.com:3211/mydb";
// Create the pool from the connection URI
var pool = PgClient.pool(connectionUri);
// Create the connection from the connection URI
PgClient.connect(vertx, connectionUri, function (res, res_err) {
// Handling your connection
});
```
More information about connection string formats can be found in the [PostgreSQL Manuals](https://www.postgresql.org/docs/9.6/static/libpq-connect.html#LIBPQ-CONNSTRING).
You can also use environment variables to set default connection setting values, this is useful
when you want to avoid hard-coding database connection information. You can refer to the [official documentation](https://www.postgresql.org/docs/9.6/static/libpq-envars.html)
for more details. The following parameters are supported:
* `PGHOST`
* `PGHOSTADDR`
* `PGPORT`
* `PGDATABASE`
* `PGUSER`
* `PGPASSWORD`
* `PGSSLMODE`
If you don't specify a data object or a connection URI string to connect, environment variables will take precedence over them.
```
$ PGUSER=user \
PGHOST=the-host \
PGPASSWORD=secret \
PGDATABASE=the-db \
PGPORT=5432 \
PGSSLMODE=DISABLE
```
```js
var PgClient = require("reactive-pg-client-js/pg_client");
// Create the pool from the environment variables
var pool = PgClient.pool();
// Create the connection from the environment variables
PgClient.connect(vertx, function (res, res_err) {
// Handling your connection
});
```
## Running queries
When you don't need a transaction or run single queries, you can run queries directly on the pool; the pool
will use one of its connection to run the query and return the result to you.
Here is how to run simple queries:
```js
client.query("SELECT * FROM users WHERE id='julien'", function (ar, ar_err) {
if (ar_err == null) {
var result = ar;
console.log("Got " + result.size() + " rows ");
} else {
console.log("Failure: " + ar_err.getMessage());
}
});
```
You can do the same with prepared queries.
The SQL string can refer to parameters by position, using `$1`, `$2`, etc…
```js
var Tuple = require("reactive-pg-client-js/tuple");
client.preparedQuery("SELECT * FROM users WHERE id=$1", Tuple.of("julien"), function (ar, ar_err) {
if (ar_err == null) {
var rows = ar;
console.log("Got " + rows.size() + " rows ");
} else {
console.log("Failure: " + ar_err.getMessage());
}
});
```
Query methods provides an asynchronous [`PgRowSet`](../../jsdoc/module-reactive-pg-client-js_pg_row_set-PgRowSet.html) instance that works for _SELECT_ queries
```js
client.preparedQuery("SELECT first_name, last_name FROM users", function (ar, ar_err) {
if (ar_err == null) {
var rows = ar;
Array.prototype.forEach.call(rows, function(row) {
console.log("User " + row.getString(0) + " " + row.getString(1));
});
} else {
console.log("Failure: " + ar_err.getMessage());
}
});
```
or _UPDATE_/_INSERT_ queries:
```js
var Tuple = require("reactive-pg-client-js/tuple");
client.preparedQuery("INSERT INTO users (first_name, last_name) VALUES ($1, $2)", Tuple.of("Julien", "Viet"), function (ar, ar_err) {
if (ar_err == null) {
var rows = ar;
console.log(rows.rowCount());
} else {
console.log("Failure: " + ar_err.getMessage());
}
});
```
The [`Row`](../../jsdoc/module-reactive-pg-client-js_row-Row.html) gives you access to your data by index
```js
console.log("User " + row.getString(0) + " " + row.getString(1));
```
or by name
```js
console.log("User " + row.getString("first_name") + " " + row.getString("last_name"));
```
You can access a wide variety of of types
```js
var firstName = row.getString("first_name");
var male = row.getBoolean("male");
var age = row.getInteger("age");
// ...
```
You can execute prepared batch
```js
var Tuple = require("reactive-pg-client-js/tuple");
// Add commands to the batch
var batch = [];
batch.push(Tuple.of("julien", "Julien Viet"));
batch.push(Tuple.of("emad", "Emad Alblueshi"));
// Execute the prepared batch
client.preparedBatch("INSERT INTO USERS (id, name) VALUES ($1, $2)", batch, function (res, res_err) {
if (res_err == null) {
// Process rows
var rows = res;
} else {
console.log("Batch failed " + res_err);
}
});
```
You can cache prepared queries:
```js
var PgClient = require("reactive-pg-client-js/pg_client");
// Enable prepare statements
options.cachePreparedStatements = true;
var client = PgClient.pool(vertx, options);
```
You can fetch generated keys with a 'RETURNING' clause in your query:
```js
var Tuple = require("reactive-pg-client-js/tuple");
client.preparedQuery("INSERT INTO color (color_name) VALUES ($1), ($2), ($3) RETURNING color_id", Tuple.of("white", "red", "blue"), function (ar, ar_err) {
if (ar_err == null) {
var rows = ar;
console.log(rows.rowCount());
Array.prototype.forEach.call(rows, function(row) {
console.log("generated key: " + row.getInteger("color_id"));
});
} else {
console.log("Failure: " + ar_err.getMessage());
}
});
```
## Using connections
When you need to execute sequential queries (without a transaction), you can create a new connection
or borrow one from the pool:
```js
Code not translatable
```
Prepared queries can be created:
```js
var Tuple = require("reactive-pg-client-js/tuple");
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", function (ar1, ar1_err) {
if (ar1_err == null) {
var pq = ar1;
pq.execute(Tuple.of("julien"), function (ar2, ar2_err) {
if (ar2_err == null) {
// All rows
var rows = ar2;
}
});
}
});
```
NOTE: prepared query caching depends on the [`cachePreparedStatements`](../dataobjects.html#PgConnectOptions#setCachePreparedStatements) and
does not depend on whether you are creating prepared queries or use [`direct prepared queries`](../../jsdoc/module-reactive-pg-client-js_pg_client-PgClient.html#preparedQuery)
[`PgPreparedQuery`](../../jsdoc/module-reactive-pg-client-js_pg_prepared_query-PgPreparedQuery.html)can perform efficient batching:
```js
var Tuple = require("reactive-pg-client-js/tuple");
connection.prepare("INSERT INTO USERS (id, name) VALUES ($1, $2)", function (ar1, ar1_err) {
if (ar1_err == null) {
var prepared = ar1;
// Create a query : bind parameters
var batch = [];
// Add commands to the createBatch
batch.push(Tuple.of("julien", "Julien Viet"));
batch.push(Tuple.of("emad", "Emad Alblueshi"));
prepared.batch(batch, function (res, res_err) {
if (res_err == null) {
// Process rows
var rows = res;
} else {
console.log("Batch failed " + res_err);
}
});
}
});
```
## Using transactions
### Transactions with connections
You can execute transaction using SQL `BEGIN`/`COMMIT`/`ROLLBACK`, if you do so you must use
a [`PgConnection`](../../jsdoc/module-reactive-pg-client-js_pg_connection-PgConnection.html) and manage it yourself.
Or you can use the transaction API of [`PgConnection`](../../jsdoc/module-reactive-pg-client-js_pg_connection-PgConnection.html):
```js
Code not translatable
```
When Postgres reports the current transaction is failed (e.g the infamous _current transaction is aborted, commands ignored until
end of transaction block_), the transaction is rollbacked and the [`abortHandler`](../../jsdoc/module-reactive-pg-client-js_pg_transaction-PgTransaction.html#abortHandler)
is called:
```js
pool.getConnection(function (res, res_err) {
if (res_err == null) {
// Transaction must use a connection
var conn = res;
// Begin the transaction
var tx = conn.begin().abortHandler(function (v) {
console.log("Transaction failed => rollbacked");
});
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", function (ar, ar_err) {
// Works fine of course
if (ar_err == null) {
} else {
tx.rollback();
conn.close();
}
});
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", function (ar, ar_err) {
// Fails and triggers transaction aborts
});
// Attempt to commit the transaction
tx.commit(function (ar, ar_err) {
// But transaction abortion fails it
// Return the connection to the pool
conn.close();
});
}
});
```
### Simplified transaction API
When you use a pool, you can start a transaction directly on the pool.
It borrows a connection from the pool, begins the transaction and releases the connection to the pool when the transaction ends.
```js
Code not translatable
```
## Cursors and streaming
By default prepared query execution fetches all rows, you can use a
[`PgCursor`](../../jsdoc/module-reactive-pg-client-js_pg_cursor-PgCursor.html)to control the amount of rows you want to read:
```js
var Tuple = require("reactive-pg-client-js/tuple");
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", function (ar1, ar1_err) {
if (ar1_err == null) {
var pq = ar1;
// Cursors require to run within a transaction
var tx = connection.begin();
// Create a cursor
var cursor = pq.cursor(Tuple.of("julien"));
// Read 50 rows
cursor.read(50, function (ar2, ar2_err) {
if (ar2_err == null) {
var rows = ar2;
// Check for more ?
if (cursor.hasMore()) {
// Repeat the process...
} else {
// No more rows - commit the transaction
tx.commit();
}
}
});
}
});
```
PostreSQL destroys cursors at the end of a transaction, so the cursor API shall be used
within a transaction, otherwise you will likely get the `34000` PostgreSQL error.
Cursors shall be closed when they are released prematurely:
```js
cursor.read(50, function (ar2, ar2_err) {
if (ar2_err == null) {
// Close the cursor
cursor.close();
}
});
```
A stream API is also available for cursors, which can be more convenient, specially with the Rxified version.
```js
var Tuple = require("reactive-pg-client-js/tuple");
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", function (ar1, ar1_err) {
if (ar1_err == null) {
var pq = ar1;
// Streams require to run within a transaction
var tx = connection.begin();
// Fetch 50 rows at a time
var stream = pq.createStream(50, Tuple.of("julien"));
// Use the stream
stream.exceptionHandler(function (err) {
console.log("Error: " + err.getMessage());
});
stream.endHandler(function (v) {
tx.commit();
console.log("End of stream");
});
stream.handler(function (row) {
console.log("User: " + row.getString("last_name"));
});
}
});
```
The stream read the rows by batch of `50` and stream them, when the rows have been passed to the handler,
a new batch of `50` is read and so on.
The stream can be resumed or paused, the loaded rows will remain in memory until they are delivered and the cursor
will stop iterating.
## Postgres type mapping
Currently the client supports the following Postgres types
* BOOLEAN (`java.lang.Boolean`)
* INT2 (`java.lang.Short`)
* INT4 (`java.lang.Integer`)
* INT8 (`java.lang.Long`)
* FLOAT4 (`java.lang.Float`)
* FLOAT8 (`java.lang.Double`)
* CHAR (`java.lang.String`)
* VARCHAR (`java.lang.String`)
* TEXT (`java.lang.String`)
* ENUM (`java.lang.String`)
* NAME (`java.lang.String`)
* SERIAL2 (`java.lang.Short`)
* SERIAL4 (`java.lang.Integer`)
* SERIAL8 (`java.lang.Long`)
* NUMERIC (`io.reactiverse.pgclient.data.Numeric`)
* UUID (`java.util.UUID`)
* DATE (`java.time.LocalDate`)
* TIME (`java.time.LocalTime`)
* TIMETZ (`java.time.OffsetTime`)
* TIMESTAMP (`java.time.LocalDateTime`)
* TIMESTAMPTZ (`java.time.OffsetDateTime`)
* INTERVAL (`io.reactiverse.pgclient.data.Interval`)
* BYTEA (`io.vertx.core.buffer.Buffer`)
* JSON (`io.reactiverse.pgclient.data.Json`)
* JSONB (`io.reactiverse.pgclient.data.Json`)
* POINT (`io.reactiverse.pgclient.data.Point`)
* LINE (`io.reactiverse.pgclient.data.Line`)
* LSEG (`io.reactiverse.pgclient.data.LineSegment`)
* BOX (`io.reactiverse.pgclient.data.Box`)
* PATH (`io.reactiverse.pgclient.data.Path`)
* POLYGON (`io.reactiverse.pgclient.data.Polygon`)
* CIRCLE (`io.reactiverse.pgclient.data.Circle`)
Tuple decoding uses the above types when storing values, it also performs on the flu conversion the actual value when possible:
```js
pool.query("SELECT 1::BIGINT \"VAL\"", function (ar, ar_err) {
var rowSet = ar;
var row = rowSet.iterator().next();
// Stored as java.lang.Long
var value = row.getValue(0);
// Convert to java.lang.Integer
var intValue = row.getInteger(0);
});
```
Tuple encoding uses the above type mapping for encoding, unless the type is numeric in which case `java.lang.Number` is used instead:
```js
pool.query("SELECT 1::BIGINT \"VAL\"", function (ar, ar_err) {
var rowSet = ar;
var row = rowSet.iterator().next();
// Stored as java.lang.Long
var value = row.getValue(0);
// Convert to java.lang.Integer
var intValue = row.getInteger(0);
});
```
Arrays of these types are supported.
### Handling JSON
The [`Json`](../../jsdoc/module-reactive-pg-client-js_json-Json.html) Java type is used to represent the Postgres `JSON` and `JSONB` type.
The main reason of this type is handling `null` JSON values.
```js
var Json = require("reactive-pg-client-js/json");
var Tuple = require("reactive-pg-client-js/tuple");
// Create a tuple
var tuple = Tuple.of(Json.create(Json.create(null)), Json.create(Json.create({
"foo" : "bar"
})), Json.create(Json.create(null)));
// Retrieving json
var value = tuple.getJson(0).value();
//
value = tuple.getJson(1).value();
//
value = tuple.getJson(3).value();
```
### Handling NUMERIC
The `Numeric` Java type is used to represent the Postgres `NUMERIC` type.
```js
var numeric = row.getNumeric("value");
if (numeric.isNaN()) {
// Handle NaN
} else {
var value = numeric.bigDecimalValue();
}
```
## Handling arrays
Arrays are available on [`Tuple`](../../jsdoc/module-reactive-pg-client-js_tuple-Tuple.html) and [`Row`](../../jsdoc/module-reactive-pg-client-js_row-Row.html):
```js
Code not translatable
```
## Handling custom types
Strings are used to represent custom types, both sent to and returned from Postgres.
You can read from Postgres and get the custom type as a string
```js
var Tuple = require("reactive-pg-client-js/tuple");
client.preparedQuery("SELECT address, (address).city FROM address_book WHERE id=$1", Tuple.of(3), function (ar, ar_err) {
if (ar_err == null) {
var rows = ar;
Array.prototype.forEach.call(rows, function(row) {
console.log("Full Address " + row.getString(0) + ", City " + row.getString(1));
});
} else {
console.log("Failure: " + ar_err.getMessage());
}
});
```
You can also write to Postgres by providing a string
```js
var Tuple = require("reactive-pg-client-js/tuple");
client.preparedQuery("INSERT INTO address_book (id, address) VALUES ($1, $2)", Tuple.of(3, "('Anytown', 'Second Ave', false)"), function (ar, ar_err) {
if (ar_err == null) {
var rows = ar;
console.log(rows.rowCount());
} else {
console.log("Failure: " + ar_err.getMessage());
}
});
```
## Collector queries
You can use Java collectors with the query API:
```js
Code not translatable
```
The collector processing must not keep a reference on the [`Row`](../../jsdoc/module-reactive-pg-client-js_row-Row.html) as
there is a single row used for processing the entire set.
The Java `Collectors` provides many interesting predefined collectors, for example you can
create easily create a string directly from the row set:
```js
Code not translatable
```
## RxJava support
The rxified API supports RxJava 1 and RxJava 2, the following examples use RxJava 2.
Most asynchronous constructs are available as methods prefixed by `rx`:
```js
Code not translatable
```
### Streaming
RxJava 2 supports `Observable` and `Flowable` types, these are exposed using
the `PgStream` that you can get
from a `PgPreparedQuery`:
```js
Code not translatable
```
The same example using `Flowable`:
```js
Code not translatable
```
### Transaction
The simplified transaction API allows to easily write transactional
asynchronous flows:
```js
Code not translatable
```
## Pub/sub
Postgres supports pub/sub communication channels.
You can set a [`notificationHandler`](../../jsdoc/module-reactive-pg-client-js_pg_connection-PgConnection.html#notificationHandler) to receive
Postgres notifications:
```js
connection.notificationHandler(function (notification) {
console.log("Received " + notification.payload + " on channel " + notification.channel);
});
connection.query("LISTEN some-channel", function (ar, ar_err) {
console.log("Subscribed to channel");
});
```
The [`PgSubscriber`](../../jsdoc/module-reactive-pg-client-js_pg_subscriber-PgSubscriber.html) is a channel manager managing a single connection that
provides per channel subscription:
```js
var PgSubscriber = require("reactive-pg-client-js/pg_subscriber");
var subscriber = PgSubscriber.subscriber(vertx, {
"port" : 5432,
"host" : "the-host",
"database" : "the-db",
"user" : "user",
"password" : "secret"
});
// You can set the channel before connect
subscriber.channel("channel1").handler(function (payload) {
console.log("Received " + payload);
});
subscriber.connect(function (ar, ar_err) {
if (ar_err == null) {
// Or you can set the channel after connect
subscriber.channel("channel2").handler(function (payload) {
console.log("Received " + payload);
});
}
});
```
The channel name that is given to the channel method will be the exact name of the channel as held by Postgres for sending
notifications. Note this is different than the representation of the channel name in SQL, and
internally [`PgSubscriber`](../../jsdoc/module-reactive-pg-client-js_pg_subscriber-PgSubscriber.html) will prepare the submitted channel name as a quoted identifier:
```js
var PgSubscriber = require("reactive-pg-client-js/pg_subscriber");
var subscriber = PgSubscriber.subscriber(vertx, {
"port" : 5432,
"host" : "the-host",
"database" : "the-db",
"user" : "user",
"password" : "secret"
});
subscriber.connect(function (ar, ar_err) {
if (ar_err == null) {
// Complex channel name - name in PostgreSQL requires a quoted ID
subscriber.channel("Complex.Channel.Name").handler(function (payload) {
console.log("Received " + payload);
});
subscriber.channel("Complex.Channel.Name").subscribeHandler(function (subscribed) {
subscriber.actualConnection().query("NOTIFY \"Complex.Channel.Name\", 'msg'", function (notified, notified_err) {
console.log("Notified \"Complex.Channel.Name\"");
});
});
// PostgreSQL simple ID's are forced lower-case
subscriber.channel("simple_channel").handler(function (payload) {
console.log("Received " + payload);
});
subscriber.channel("simple_channel").subscribeHandler(function (subscribed) {
// The following simple channel identifier is forced to lower case
subscriber.actualConnection().query("NOTIFY Simple_CHANNEL, 'msg'", function (notified, notified_err) {
console.log("Notified simple_channel");
});
});
// The following channel name is longer than the current
// (NAMEDATALEN = 64) - 1 == 63 character limit and will be truncated
subscriber.channel("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbb").handler(function (payload) {
console.log("Received " + payload);
});
}
});
```
You can provide a reconnect policy as a function that takes the number of `retries` as argument and returns an `amountOfTime`
value:
* when `amountOfTime < 0`: the subscriber is closed and there is no retry
* when `amountOfTime = 0`: the subscriber retries to connect immediately
* when `amountOfTime > 0`: the subscriber retries after `amountOfTime` milliseconds
```js
var PgSubscriber = require("reactive-pg-client-js/pg_subscriber");
var subscriber = PgSubscriber.subscriber(vertx, {
"port" : 5432,
"host" : "the-host",
"database" : "the-db",
"user" : "user",
"password" : "secret"
});
// Reconnect at most 10 times after 100 ms each
subscriber.reconnectPolicy(function (retries) {
if (retries < 10) {
return 100
} else {
return -1
}
});
```
The default policy is to not reconnect.
## Cancelling Request
Postgres supports cancellation of requests in progress. You can cancel inflight requests using [`cancelRequest`](../../jsdoc/module-reactive-pg-client-js_pg_connection-PgConnection.html#cancelRequest). Cancelling a request opens a new connection to the server and cancels the request and then close the connection.
```js
connection.query("SELECT pg_sleep(20)", function (ar, ar_err) {
if (ar_err == null) {
// imagine this is a long query and is still running
console.log("Query success");
} else {
// the server will abort the current query after cancelling request
console.log("Failed to query due to " + ar_err.getMessage());
}
});
connection.cancelRequest(function (ar, ar_err) {
if (ar_err == null) {
console.log("Cancelling request has been sent");
} else {
console.log("Failed to send cancelling request");
}
});
```
> The cancellation signal might or might not have any effect — for example, if it arrives after the backend has finished processing the query, then it will have no effect. If the cancellation is effective, it results in the current command being terminated early with an error message.
More information can be found in the [official documentation](https://www.postgresql.org/docs/11/protocol-flow.html#id-1.10.5.7.9).
## Using SSL/TLS
To configure the client to use SSL connection, you can configure the [`PgConnectOptions`](../dataobjects.html#PgConnectOptions)
like a Vert.x `NetClient`.
All [SSL modes](https://www.postgresql.org/docs/current/libpq-ssl.html#LIBPQ-SSL-PROTECTION) are supported and you are able to configure `sslmode`. The client is in `DISABLE` SSL mode by default.
`ssl` parameter is kept as a mere shortcut for setting `sslmode`. `setSsl(true)` is equivalent to `setSslMode(VERIFY_CA)` and `setSsl(false)` is equivalent to `setSslMode(DISABLE)`.
```js
var PgClient = require("reactive-pg-client-js/pg_client");
var options = {
"port" : 5432,
"host" : "the-host",
"database" : "the-db",
"user" : "user",
"password" : "secret",
"sslMode" : "VERIFY_CA",
"pemTrustOptions" : {
"certPaths" : [
"/path/to/cert.pem"
]
}
};
PgClient.connect(vertx, options, function (res, res_err) {
if (res_err == null) {
// Connected with SSL
} else {
console.log("Could not connect " + res_err);
}
});
```
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#ssl).
## Using a proxy
You can also configure the client to use an HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy.
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#_using_a_proxy_for_client_connections).
================================================
FILE: docs/guide/kotlin/index.md
================================================
# Reactive Postgres Client
The Reactive Postgres Client is a client for Postgres with a straightforward API focusing on
scalability and low overhead.
The client is reactive and non blocking, allowing to handle many database connections with a single thread.
* Event driven
* Lightweight
* Built-in connection pooling
* Prepared queries caching
* Publish / subscribe using Postgres `NOTIFY/LISTEN`
* Batch and cursor
* Row streaming
* Command pipeling
* RxJava 1 and RxJava 2
* Direct memory to object without unnecessary copies
* Java 8 Date and Time
* SSL/TLS
* Unix domain socket
* HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy support
## Usage
To use the Reactive Postgres Client add the following dependency to the _dependencies_ section of your build descriptor:
* Maven (in your `pom.xml`):
```xml
io.reactiversereactive-pg-client0.11.4
```
* Gradle (in your `build.gradle` file):
```groovy
dependencies {
compile 'io.reactiverse:reactive-pg-client:0.11.4'
}
```
## Getting started
Here is the simplest way to connect, query and disconnect
```kotlin
// Pool options
var options = PgPoolOptions(
port = 5432,
host = "the-host",
database = "the-db",
user = "user",
password = "secret",
maxSize = 5)
// Create the client pool
var client = PgClient.pool(options)
// A simple query
client.query("SELECT * FROM users WHERE id='julien'", { ar ->
if (ar.succeeded()) {
var result = ar.result()
println("Got ${result.size()} rows ")
} else {
println("Failure: ${ar.cause().getMessage()}")
}
// Now close the pool
client.close()
})
```
## Connecting to Postgres
Most of the time you will use a pool to connect to Postgres:
```kotlin
// Pool options
var options = PgPoolOptions(
port = 5432,
host = "the-host",
database = "the-db",
user = "user",
password = "secret",
maxSize = 5)
// Create the pooled client
var client = PgClient.pool(options)
```
The pooled client uses a connection pool and any operation will borrow a connection from the pool
to execute the operation and release it to the pool.
If you are running with Vert.x you can pass it your Vertx instance:
```kotlin
// Pool options
var options = PgPoolOptions(
port = 5432,
host = "the-host",
database = "the-db",
user = "user",
password = "secret",
maxSize = 5)
// Create the pooled client
var client = PgClient.pool(vertx, options)
```
You need to release the pool when you don't need it anymore:
```kotlin
// Close the pool and all the associated resources
pool.close()
```
When you need to execute several operations on the same connection, you need to use a client
[`connection`](../../apidocs/io/reactiverse/pgclient/PgConnection.html).
You can easily get one from the pool:
```kotlin
// Pool options
var options = PgPoolOptions(
port = 5432,
host = "the-host",
database = "the-db",
user = "user",
password = "secret",
maxSize = 5)
// Create the pooled client
var client = PgClient.pool(vertx, options)
// Get a connection from the pool
client.getConnection({ ar1 ->
if (ar1.succeeded()) {
println("Connected")
// Obtain our connection
var conn = ar1.result()
// All operations execute on the same connection
conn.query("SELECT * FROM users WHERE id='julien'", { ar2 ->
if (ar2.succeeded()) {
conn.query("SELECT * FROM users WHERE id='emad'", { ar3 ->
// Release the connection to the pool
conn.close()
})
} else {
// Release the connection to the pool
conn.close()
}
})
} else {
println("Could not connect: ${ar1.cause().getMessage()}")
}
})
```
Once you are done with the connection you must close it to release it to the pool, so it can be reused.
Sometimes you want to improve performance via Unix domain socket connection, we achieve this with Vert.x Native transports.
Make sure you have added the required `netty-transport-native` dependency in your classpath and enabled the Unix domain socket option.
```kotlin
// Pool Options
// Socket file name will be /var/run/postgresql/.s.PGSQL.5432
var options = PgPoolOptions(
host = "/var/run/postgresql",
port = 5432,
database = "the-db")
// Create the pooled client
var client = PgClient.pool(options)
// Create the pooled client with a vertx instance
// Make sure the vertx instance has enabled native transports
var client2 = PgClient.pool(vertx, options)
```
More information can be found in the [Vert.x documentation](https://vertx.io/docs/vertx-core/java/#_native_transports).
## Configuration
There are several options for you to configure the client.
Apart from configuring with a `PgPoolOptions` data object, We also provide you an alternative way to connect when you want to configure with a connection URI:
```kotlin
// Connection URI
var connectionUri = "postgresql://dbuser:secretpassword@database.server.com:3211/mydb"
// Create the pool from the connection URI
var pool = PgClient.pool(connectionUri)
// Create the connection from the connection URI
PgClient.connect(vertx, connectionUri, { res ->
// Handling your connection
})
```
More information about connection string formats can be found in the [PostgreSQL Manuals](https://www.postgresql.org/docs/9.6/static/libpq-connect.html#LIBPQ-CONNSTRING).
You can also use environment variables to set default connection setting values, this is useful
when you want to avoid hard-coding database connection information. You can refer to the [official documentation](https://www.postgresql.org/docs/9.6/static/libpq-envars.html)
for more details. The following parameters are supported:
* `PGHOST`
* `PGHOSTADDR`
* `PGPORT`
* `PGDATABASE`
* `PGUSER`
* `PGPASSWORD`
* `PGSSLMODE`
If you don't specify a data object or a connection URI string to connect, environment variables will take precedence over them.
```
$ PGUSER=user \
PGHOST=the-host \
PGPASSWORD=secret \
PGDATABASE=the-db \
PGPORT=5432 \
PGSSLMODE=DISABLE
```
```kotlin
// Create the pool from the environment variables
var pool = PgClient.pool()
// Create the connection from the environment variables
PgClient.connect(vertx, { res ->
// Handling your connection
})
```
## Running queries
When you don't need a transaction or run single queries, you can run queries directly on the pool; the pool
will use one of its connection to run the query and return the result to you.
Here is how to run simple queries:
```kotlin
client.query("SELECT * FROM users WHERE id='julien'", { ar ->
if (ar.succeeded()) {
var result = ar.result()
println("Got ${result.size()} rows ")
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
You can do the same with prepared queries.
The SQL string can refer to parameters by position, using `$1`, `$2`, etc…
```kotlin
client.preparedQuery("SELECT * FROM users WHERE id=\$$1", Tuple.of("julien"), { ar ->
if (ar.succeeded()) {
var rows = ar.result()
println("Got ${rows.size()} rows ")
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
Query methods provides an asynchronous [`PgRowSet`](../../apidocs/io/reactiverse/pgclient/PgRowSet.html) instance that works for _SELECT_ queries
```kotlin
client.preparedQuery("SELECT first_name, last_name FROM users", { ar ->
if (ar.succeeded()) {
var rows = ar.result()
for (row in rows) {
println("User ${row.getString(0)} ${row.getString(1)}")
}
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
or _UPDATE_/_INSERT_ queries:
```kotlin
client.preparedQuery("INSERT INTO users (first_name, last_name) VALUES (\$$1, \$$2)", Tuple.of("Julien", "Viet"), { ar ->
if (ar.succeeded()) {
var rows = ar.result()
println(rows.rowCount())
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
The [`Row`](../../apidocs/io/reactiverse/pgclient/Row.html) gives you access to your data by index
```kotlin
println("User ${row.getString(0)} ${row.getString(1)}")
```
or by name
```kotlin
println("User ${row.getString("first_name")} ${row.getString("last_name")}")
```
You can access a wide variety of of types
```kotlin
var firstName = row.getString("first_name")
var male = row.getBoolean("male")
var age = row.getInteger("age")
// ...
```
You can execute prepared batch
```kotlin
// Add commands to the batch
var batch = mutableListOf()
batch.add(Tuple.of("julien", "Julien Viet"))
batch.add(Tuple.of("emad", "Emad Alblueshi"))
// Execute the prepared batch
client.preparedBatch("INSERT INTO USERS (id, name) VALUES (\$$1, \$$2)", batch, { res ->
if (res.succeeded()) {
// Process rows
var rows = res.result()
} else {
println("Batch failed ${res.cause()}")
}
})
```
You can cache prepared queries:
```kotlin
// Enable prepare statements
options.cachePreparedStatements = true
var client = PgClient.pool(vertx, options)
```
You can fetch generated keys with a 'RETURNING' clause in your query:
```kotlin
client.preparedQuery("INSERT INTO color (color_name) VALUES (\$$1), (\$$2), (\$$3) RETURNING color_id", Tuple.of("white", "red", "blue"), { ar ->
if (ar.succeeded()) {
var rows = ar.result()
println(rows.rowCount())
for (row in rows) {
println("generated key: ${row.getInteger("color_id")}")
}
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
## Using connections
When you need to execute sequential queries (without a transaction), you can create a new connection
or borrow one from the pool:
```kotlin
Code not translatable
```
Prepared queries can be created:
```kotlin
connection.prepare("SELECT * FROM users WHERE first_name LIKE \$$1", { ar1 ->
if (ar1.succeeded()) {
var pq = ar1.result()
pq.execute(Tuple.of("julien"), { ar2 ->
if (ar2.succeeded()) {
// All rows
var rows = ar2.result()
}
})
}
})
```
NOTE: prepared query caching depends on the [`setCachePreparedStatements`](../../apidocs/io/reactiverse/pgclient/PgConnectOptions.html#setCachePreparedStatements-boolean-) and
does not depend on whether you are creating prepared queries or use [`direct prepared queries`](../../apidocs/io/reactiverse/pgclient/PgClient.html#preparedQuery-java.lang.String-io.vertx.core.Handler-)
[`PgPreparedQuery`](../../apidocs/io/reactiverse/pgclient/PgPreparedQuery.html)can perform efficient batching:
```kotlin
connection.prepare("INSERT INTO USERS (id, name) VALUES (\$$1, \$$2)", { ar1 ->
if (ar1.succeeded()) {
var prepared = ar1.result()
// Create a query : bind parameters
var batch = mutableListOf()
// Add commands to the createBatch
batch.add(Tuple.of("julien", "Julien Viet"))
batch.add(Tuple.of("emad", "Emad Alblueshi"))
prepared.batch(batch, { res ->
if (res.succeeded()) {
// Process rows
var rows = res.result()
} else {
println("Batch failed ${res.cause()}")
}
})
}
})
```
## Using transactions
### Transactions with connections
You can execute transaction using SQL `BEGIN`/`COMMIT`/`ROLLBACK`, if you do so you must use
a [`PgConnection`](../../apidocs/io/reactiverse/pgclient/PgConnection.html) and manage it yourself.
Or you can use the transaction API of [`PgConnection`](../../apidocs/io/reactiverse/pgclient/PgConnection.html):
```kotlin
Code not translatable
```
When Postgres reports the current transaction is failed (e.g the infamous _current transaction is aborted, commands ignored until
end of transaction block_), the transaction is rollbacked and the [`abortHandler`](../../apidocs/io/reactiverse/pgclient/PgTransaction.html#abortHandler-io.vertx.core.Handler-)
is called:
```kotlin
pool.getConnection({ res ->
if (res.succeeded()) {
// Transaction must use a connection
var conn = res.result()
// Begin the transaction
var tx = conn.begin().abortHandler({ v ->
println("Transaction failed => rollbacked")
})
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", { ar ->
// Works fine of course
if (ar.succeeded()) {
} else {
tx.rollback()
conn.close()
}
})
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", { ar ->
// Fails and triggers transaction aborts
})
// Attempt to commit the transaction
tx.commit({ ar ->
// But transaction abortion fails it
// Return the connection to the pool
conn.close()
})
}
})
```
### Simplified transaction API
When you use a pool, you can start a transaction directly on the pool.
It borrows a connection from the pool, begins the transaction and releases the connection to the pool when the transaction ends.
```kotlin
Code not translatable
```
## Cursors and streaming
By default prepared query execution fetches all rows, you can use a
[`PgCursor`](../../apidocs/io/reactiverse/pgclient/PgCursor.html)to control the amount of rows you want to read:
```kotlin
connection.prepare("SELECT * FROM users WHERE first_name LIKE \$$1", { ar1 ->
if (ar1.succeeded()) {
var pq = ar1.result()
// Cursors require to run within a transaction
var tx = connection.begin()
// Create a cursor
var cursor = pq.cursor(Tuple.of("julien"))
// Read 50 rows
cursor.read(50, { ar2 ->
if (ar2.succeeded()) {
var rows = ar2.result()
// Check for more ?
if (cursor.hasMore()) {
// Repeat the process...
} else {
// No more rows - commit the transaction
tx.commit()
}
}
})
}
})
```
PostreSQL destroys cursors at the end of a transaction, so the cursor API shall be used
within a transaction, otherwise you will likely get the `34000` PostgreSQL error.
Cursors shall be closed when they are released prematurely:
```kotlin
cursor.read(50, { ar2 ->
if (ar2.succeeded()) {
// Close the cursor
cursor.close()
}
})
```
A stream API is also available for cursors, which can be more convenient, specially with the Rxified version.
```kotlin
connection.prepare("SELECT * FROM users WHERE first_name LIKE \$$1", { ar1 ->
if (ar1.succeeded()) {
var pq = ar1.result()
// Streams require to run within a transaction
var tx = connection.begin()
// Fetch 50 rows at a time
var stream = pq.createStream(50, Tuple.of("julien"))
// Use the stream
stream.exceptionHandler({ err ->
println("Error: ${err.getMessage()}")
})
stream.endHandler({ v ->
tx.commit()
println("End of stream")
})
stream.handler({ row ->
println("User: ${row.getString("last_name")}")
})
}
})
```
The stream read the rows by batch of `50` and stream them, when the rows have been passed to the handler,
a new batch of `50` is read and so on.
The stream can be resumed or paused, the loaded rows will remain in memory until they are delivered and the cursor
will stop iterating.
## Postgres type mapping
Currently the client supports the following Postgres types
* BOOLEAN (`java.lang.Boolean`)
* INT2 (`java.lang.Short`)
* INT4 (`java.lang.Integer`)
* INT8 (`java.lang.Long`)
* FLOAT4 (`java.lang.Float`)
* FLOAT8 (`java.lang.Double`)
* CHAR (`java.lang.String`)
* VARCHAR (`java.lang.String`)
* TEXT (`java.lang.String`)
* ENUM (`java.lang.String`)
* NAME (`java.lang.String`)
* SERIAL2 (`java.lang.Short`)
* SERIAL4 (`java.lang.Integer`)
* SERIAL8 (`java.lang.Long`)
* NUMERIC (`io.reactiverse.pgclient.data.Numeric`)
* UUID (`java.util.UUID`)
* DATE (`java.time.LocalDate`)
* TIME (`java.time.LocalTime`)
* TIMETZ (`java.time.OffsetTime`)
* TIMESTAMP (`java.time.LocalDateTime`)
* TIMESTAMPTZ (`java.time.OffsetDateTime`)
* INTERVAL (`io.reactiverse.pgclient.data.Interval`)
* BYTEA (`io.vertx.core.buffer.Buffer`)
* JSON (`io.reactiverse.pgclient.data.Json`)
* JSONB (`io.reactiverse.pgclient.data.Json`)
* POINT (`io.reactiverse.pgclient.data.Point`)
* LINE (`io.reactiverse.pgclient.data.Line`)
* LSEG (`io.reactiverse.pgclient.data.LineSegment`)
* BOX (`io.reactiverse.pgclient.data.Box`)
* PATH (`io.reactiverse.pgclient.data.Path`)
* POLYGON (`io.reactiverse.pgclient.data.Polygon`)
* CIRCLE (`io.reactiverse.pgclient.data.Circle`)
Tuple decoding uses the above types when storing values, it also performs on the flu conversion the actual value when possible:
```kotlin
pool.query("SELECT 1::BIGINT \"VAL\"", { ar ->
var rowSet = ar.result()
var row = rowSet.iterator().next()
// Stored as java.lang.Long
var value = row.getValue(0)
// Convert to java.lang.Integer
var intValue = row.getInteger(0)
})
```
Tuple encoding uses the above type mapping for encoding, unless the type is numeric in which case `java.lang.Number` is used instead:
```kotlin
pool.query("SELECT 1::BIGINT \"VAL\"", { ar ->
var rowSet = ar.result()
var row = rowSet.iterator().next()
// Stored as java.lang.Long
var value = row.getValue(0)
// Convert to java.lang.Integer
var intValue = row.getInteger(0)
})
```
Arrays of these types are supported.
### Handling JSON
The [`Json`](../../apidocs/io/reactiverse/pgclient/data/Json.html) Java type is used to represent the Postgres `JSON` and `JSONB` type.
The main reason of this type is handling `null` JSON values.
```kotlin
// Create a tuple
var tuple = Tuple.of(Json.create(Json.create(null)), Json.create(Json.create(json {
obj("foo" to "bar")
})), Json.create(Json.create(null)))
// Retrieving json
var value = tuple.getJson(0).value()
//
value = tuple.getJson(1).value()
//
value = tuple.getJson(3).value()
```
### Handling NUMERIC
The [`Numeric`](../../apidocs/io/reactiverse/pgclient/data/Numeric.html) Java type is used to represent the Postgres `NUMERIC` type.
```kotlin
var numeric = row.getNumeric("value")
if (numeric.isNaN()) {
// Handle NaN
} else {
var value = numeric.bigDecimalValue()
}
```
## Handling arrays
Arrays are available on [`Tuple`](../../apidocs/io/reactiverse/pgclient/Tuple.html) and [`Row`](../../apidocs/io/reactiverse/pgclient/Row.html):
```kotlin
Code not translatable
```
## Handling custom types
Strings are used to represent custom types, both sent to and returned from Postgres.
You can read from Postgres and get the custom type as a string
```kotlin
client.preparedQuery("SELECT address, (address).city FROM address_book WHERE id=\$$1", Tuple.of(3), { ar ->
if (ar.succeeded()) {
var rows = ar.result()
for (row in rows) {
println("Full Address ${row.getString(0)}, City ${row.getString(1)}")
}
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
You can also write to Postgres by providing a string
```kotlin
client.preparedQuery("INSERT INTO address_book (id, address) VALUES (\$$1, \$$2)", Tuple.of(3, "('Anytown', 'Second Ave', false)"), { ar ->
if (ar.succeeded()) {
var rows = ar.result()
println(rows.rowCount())
} else {
println("Failure: ${ar.cause().getMessage()}")
}
})
```
## Collector queries
You can use Java collectors with the query API:
```kotlin
Code not translatable
```
The collector processing must not keep a reference on the [`Row`](../../apidocs/io/reactiverse/pgclient/Row.html) as
there is a single row used for processing the entire set.
The Java `Collectors` provides many interesting predefined collectors, for example you can
create easily create a string directly from the row set:
```kotlin
Code not translatable
```
## RxJava support
The rxified API supports RxJava 1 and RxJava 2, the following examples use RxJava 2.
Most asynchronous constructs are available as methods prefixed by `rx`:
```kotlin
Code not translatable
```
### Streaming
RxJava 2 supports `Observable` and `Flowable` types, these are exposed using
the [`PgStream`](../../apidocs/io/reactiverse/reactivex/pgclient/PgStream.html) that you can get
from a [`PgPreparedQuery`](../../apidocs/io/reactiverse/reactivex/pgclient/PgPreparedQuery.html):
```kotlin
Code not translatable
```
The same example using `Flowable`:
```kotlin
Code not translatable
```
### Transaction
The simplified transaction API allows to easily write transactional
asynchronous flows:
```kotlin
Code not translatable
```
## Pub/sub
Postgres supports pub/sub communication channels.
You can set a [`notificationHandler`](../../apidocs/io/reactiverse/pgclient/PgConnection.html#notificationHandler-io.vertx.core.Handler-) to receive
Postgres notifications:
```kotlin
connection.notificationHandler({ notification ->
println("Received ${notification.payload} on channel ${notification.channel}")
})
connection.query("LISTEN some-channel", { ar ->
println("Subscribed to channel")
})
```
The [`PgSubscriber`](../../apidocs/io/reactiverse/pgclient/pubsub/PgSubscriber.html) is a channel manager managing a single connection that
provides per channel subscription:
```kotlin
var subscriber = PgSubscriber.subscriber(vertx, PgConnectOptions(
port = 5432,
host = "the-host",
database = "the-db",
user = "user",
password = "secret"))
// You can set the channel before connect
subscriber.channel("channel1").handler({ payload ->
println("Received ${payload}")
})
subscriber.connect({ ar ->
if (ar.succeeded()) {
// Or you can set the channel after connect
subscriber.channel("channel2").handler({ payload ->
println("Received ${payload}")
})
}
})
```
The channel name that is given to the channel method will be the exact name of the channel as held by Postgres for sending
notifications. Note this is different than the representation of the channel name in SQL, and
internally [`PgSubscriber`](../../apidocs/io/reactiverse/pgclient/pubsub/PgSubscriber.html) will prepare the submitted channel name as a quoted identifier:
```kotlin
var subscriber = PgSubscriber.subscriber(vertx, PgConnectOptions(
port = 5432,
host = "the-host",
database = "the-db",
user = "user",
password = "secret"))
subscriber.connect({ ar ->
if (ar.succeeded()) {
// Complex channel name - name in PostgreSQL requires a quoted ID
subscriber.channel("Complex.Channel.Name").handler({ payload ->
println("Received ${payload}")
})
subscriber.channel("Complex.Channel.Name").subscribeHandler({ subscribed ->
subscriber.actualConnection().query("NOTIFY \"Complex.Channel.Name\", 'msg'", { notified ->
println("Notified \"Complex.Channel.Name\"")
})
})
// PostgreSQL simple ID's are forced lower-case
subscriber.channel("simple_channel").handler({ payload ->
println("Received ${payload}")
})
subscriber.channel("simple_channel").subscribeHandler({ subscribed ->
// The following simple channel identifier is forced to lower case
subscriber.actualConnection().query("NOTIFY Simple_CHANNEL, 'msg'", { notified ->
println("Notified simple_channel")
})
})
// The following channel name is longer than the current
// (NAMEDATALEN = 64) - 1 == 63 character limit and will be truncated
subscriber.channel("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbb").handler({ payload ->
println("Received ${payload}")
})
}
})
```
You can provide a reconnect policy as a function that takes the number of `retries` as argument and returns an `amountOfTime`
value:
* when `amountOfTime < 0`: the subscriber is closed and there is no retry
* when `amountOfTime = 0`: the subscriber retries to connect immediately
* when `amountOfTime > 0`: the subscriber retries after `amountOfTime` milliseconds
```kotlin
var subscriber = PgSubscriber.subscriber(vertx, PgConnectOptions(
port = 5432,
host = "the-host",
database = "the-db",
user = "user",
password = "secret"))
// Reconnect at most 10 times after 100 ms each
subscriber.reconnectPolicy({ retries ->
if (retries < 10) {
return 100L
} else {
return -1L
}
})
```
The default policy is to not reconnect.
## Cancelling Request
Postgres supports cancellation of requests in progress. You can cancel inflight requests using [`cancelRequest`](../../apidocs/io/reactiverse/pgclient/PgConnection.html#cancelRequest-io.vertx.core.Handler-). Cancelling a request opens a new connection to the server and cancels the request and then close the connection.
```kotlin
connection.query("SELECT pg_sleep(20)", { ar ->
if (ar.succeeded()) {
// imagine this is a long query and is still running
println("Query success")
} else {
// the server will abort the current query after cancelling request
println("Failed to query due to ${ar.cause().getMessage()}")
}
})
connection.cancelRequest({ ar ->
if (ar.succeeded()) {
println("Cancelling request has been sent")
} else {
println("Failed to send cancelling request")
}
})
```
> The cancellation signal might or might not have any effect — for example, if it arrives after the backend has finished processing the query, then it will have no effect. If the cancellation is effective, it results in the current command being terminated early with an error message.
More information can be found in the [official documentation](https://www.postgresql.org/docs/11/protocol-flow.html#id-1.10.5.7.9).
## Using SSL/TLS
To configure the client to use SSL connection, you can configure the [`PgConnectOptions`](../../apidocs/io/reactiverse/pgclient/PgConnectOptions.html)
like a Vert.x `NetClient`.
All [SSL modes](https://www.postgresql.org/docs/current/libpq-ssl.html#LIBPQ-SSL-PROTECTION) are supported and you are able to configure `sslmode`. The client is in `DISABLE` SSL mode by default.
`ssl` parameter is kept as a mere shortcut for setting `sslmode`. `setSsl(true)` is equivalent to `setSslMode(VERIFY_CA)` and `setSsl(false)` is equivalent to `setSslMode(DISABLE)`.
```kotlin
var options = PgConnectOptions(
port = 5432,
host = "the-host",
database = "the-db",
user = "user",
password = "secret",
sslMode = SslMode.VERIFY_CA,
pemTrustOptions = PemTrustOptions(
certPaths = listOf("/path/to/cert.pem")))
PgClient.connect(vertx, options, { res ->
if (res.succeeded()) {
// Connected with SSL
} else {
println("Could not connect ${res.cause()}")
}
})
```
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#ssl).
## Using a proxy
You can also configure the client to use an HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy.
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#_using_a_proxy_for_client_connections).
================================================
FILE: docs/guide/ruby/index.md
================================================
# Reactive Postgres Client
The Reactive Postgres Client is a client for Postgres with a straightforward API focusing on
scalability and low overhead.
The client is reactive and non blocking, allowing to handle many database connections with a single thread.
* Event driven
* Lightweight
* Built-in connection pooling
* Prepared queries caching
* Publish / subscribe using Postgres `NOTIFY/LISTEN`
* Batch and cursor
* Row streaming
* Command pipeling
* RxJava 1 and RxJava 2
* Direct memory to object without unnecessary copies
* Java 8 Date and Time
* SSL/TLS
* Unix domain socket
* HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy support
## Usage
To use the Reactive Postgres Client add the following dependency to the _dependencies_ section of your build descriptor:
* Maven (in your `pom.xml`):
```xml
io.reactiversereactive-pg-client0.11.4
```
* Gradle (in your `build.gradle` file):
```groovy
dependencies {
compile 'io.reactiverse:reactive-pg-client:0.11.4'
}
```
## Getting started
Here is the simplest way to connect, query and disconnect
```ruby
require 'reactive-pg-client/pg_client'
# Pool options
options = {
'port' => 5432,
'host' => "the-host",
'database' => "the-db",
'user' => "user",
'password' => "secret",
'maxSize' => 5
}
# Create the client pool
client = ReactivePgClient::PgClient.pool(options)
# A simple query
client.query("SELECT * FROM users WHERE id='julien'") { |ar_err,ar|
if (ar_err == nil)
result = ar
puts "Got #{result.size()} rows "
else
puts "Failure: #{ar_err.get_message()}"
end
# Now close the pool
client.close()
}
```
## Connecting to Postgres
Most of the time you will use a pool to connect to Postgres:
```ruby
require 'reactive-pg-client/pg_client'
# Pool options
options = {
'port' => 5432,
'host' => "the-host",
'database' => "the-db",
'user' => "user",
'password' => "secret",
'maxSize' => 5
}
# Create the pooled client
client = ReactivePgClient::PgClient.pool(options)
```
The pooled client uses a connection pool and any operation will borrow a connection from the pool
to execute the operation and release it to the pool.
If you are running with Vert.x you can pass it your Vertx instance:
```ruby
require 'reactive-pg-client/pg_client'
# Pool options
options = {
'port' => 5432,
'host' => "the-host",
'database' => "the-db",
'user' => "user",
'password' => "secret",
'maxSize' => 5
}
# Create the pooled client
client = ReactivePgClient::PgClient.pool(vertx, options)
```
You need to release the pool when you don't need it anymore:
```ruby
# Close the pool and all the associated resources
pool.close()
```
When you need to execute several operations on the same connection, you need to use a client
[`connection`](../../yardoc/ReactivePgClient/PgConnection.html).
You can easily get one from the pool:
```ruby
require 'reactive-pg-client/pg_client'
# Pool options
options = {
'port' => 5432,
'host' => "the-host",
'database' => "the-db",
'user' => "user",
'password' => "secret",
'maxSize' => 5
}
# Create the pooled client
client = ReactivePgClient::PgClient.pool(vertx, options)
# Get a connection from the pool
client.get_connection() { |ar1_err,ar1|
if (ar1_err == nil)
puts "Connected"
# Obtain our connection
conn = ar1
# All operations execute on the same connection
conn.query("SELECT * FROM users WHERE id='julien'") { |ar2_err,ar2|
if (ar2_err == nil)
conn.query("SELECT * FROM users WHERE id='emad'") { |ar3_err,ar3|
# Release the connection to the pool
conn.close()
}
else
# Release the connection to the pool
conn.close()
end
}
else
puts "Could not connect: #{ar1_err.get_message()}"
end
}
```
Once you are done with the connection you must close it to release it to the pool, so it can be reused.
Sometimes you want to improve performance via Unix domain socket connection, we achieve this with Vert.x Native transports.
Make sure you have added the required `netty-transport-native` dependency in your classpath and enabled the Unix domain socket option.
```ruby
require 'reactive-pg-client/pg_client'
# Pool Options
# Socket file name will be /var/run/postgresql/.s.PGSQL.5432
options = {
'host' => "/var/run/postgresql",
'port' => 5432,
'database' => "the-db"
}
# Create the pooled client
client = ReactivePgClient::PgClient.pool(options)
# Create the pooled client with a vertx instance
# Make sure the vertx instance has enabled native transports
client2 = ReactivePgClient::PgClient.pool(vertx, options)
```
More information can be found in the [Vert.x documentation](https://vertx.io/docs/vertx-core/java/#_native_transports).
## Configuration
There are several options for you to configure the client.
Apart from configuring with a `PgPoolOptions` data object, We also provide you an alternative way to connect when you want to configure with a connection URI:
```ruby
require 'reactive-pg-client/pg_client'
# Connection URI
connectionUri = "postgresql://dbuser:secretpassword@database.server.com:3211/mydb"
# Create the pool from the connection URI
pool = ReactivePgClient::PgClient.pool(connectionUri)
# Create the connection from the connection URI
ReactivePgClient::PgClient.connect(vertx, connectionUri) { |res_err,res|
# Handling your connection
}
```
More information about connection string formats can be found in the [PostgreSQL Manuals](https://www.postgresql.org/docs/9.6/static/libpq-connect.html#LIBPQ-CONNSTRING).
You can also use environment variables to set default connection setting values, this is useful
when you want to avoid hard-coding database connection information. You can refer to the [official documentation](https://www.postgresql.org/docs/9.6/static/libpq-envars.html)
for more details. The following parameters are supported:
* `PGHOST`
* `PGHOSTADDR`
* `PGPORT`
* `PGDATABASE`
* `PGUSER`
* `PGPASSWORD`
* `PGSSLMODE`
If you don't specify a data object or a connection URI string to connect, environment variables will take precedence over them.
```
$ PGUSER=user \
PGHOST=the-host \
PGPASSWORD=secret \
PGDATABASE=the-db \
PGPORT=5432 \
PGSSLMODE=DISABLE
```
```ruby
require 'reactive-pg-client/pg_client'
# Create the pool from the environment variables
pool = ReactivePgClient::PgClient.pool()
# Create the connection from the environment variables
ReactivePgClient::PgClient.connect(vertx) { |res_err,res|
# Handling your connection
}
```
## Running queries
When you don't need a transaction or run single queries, you can run queries directly on the pool; the pool
will use one of its connection to run the query and return the result to you.
Here is how to run simple queries:
```ruby
client.query("SELECT * FROM users WHERE id='julien'") { |ar_err,ar|
if (ar_err == nil)
result = ar
puts "Got #{result.size()} rows "
else
puts "Failure: #{ar_err.get_message()}"
end
}
```
You can do the same with prepared queries.
The SQL string can refer to parameters by position, using `$1`, `$2`, etc…
```ruby
require 'reactive-pg-client/tuple'
client.prepared_query("SELECT * FROM users WHERE id=$1", ReactivePgClient::Tuple.of("julien")) { |ar_err,ar|
if (ar_err == nil)
rows = ar
puts "Got #{rows.size()} rows "
else
puts "Failure: #{ar_err.get_message()}"
end
}
```
Query methods provides an asynchronous [`PgRowSet`](../../yardoc/ReactivePgClient/PgRowSet.html) instance that works for _SELECT_ queries
```ruby
client.prepared_query("SELECT first_name, last_name FROM users") { |ar_err,ar|
if (ar_err == nil)
rows = ar
rows.each do |row|
puts "User #{row.get_string(0)} #{row.get_string(1)}"
end
else
puts "Failure: #{ar_err.get_message()}"
end
}
```
or _UPDATE_/_INSERT_ queries:
```ruby
require 'reactive-pg-client/tuple'
client.prepared_query("INSERT INTO users (first_name, last_name) VALUES ($1, $2)", ReactivePgClient::Tuple.of("Julien", "Viet")) { |ar_err,ar|
if (ar_err == nil)
rows = ar
puts rows.row_count()
else
puts "Failure: #{ar_err.get_message()}"
end
}
```
The [`Row`](../../yardoc/ReactivePgClient/Row.html) gives you access to your data by index
```ruby
puts "User #{row.get_string(0)} #{row.get_string(1)}"
```
or by name
```ruby
puts "User #{row.get_string("first_name")} #{row.get_string("last_name")}"
```
You can access a wide variety of of types
```ruby
firstName = row.get_string("first_name")
male = row.get_boolean?("male")
age = row.get_integer("age")
# ...
```
You can execute prepared batch
```ruby
require 'reactive-pg-client/tuple'
# Add commands to the batch
batch = Array.new
batch.push(ReactivePgClient::Tuple.of("julien", "Julien Viet"))
batch.push(ReactivePgClient::Tuple.of("emad", "Emad Alblueshi"))
# Execute the prepared batch
client.prepared_batch("INSERT INTO USERS (id, name) VALUES ($1, $2)", batch) { |res_err,res|
if (res_err == nil)
# Process rows
rows = res
else
puts "Batch failed #{res_err}"
end
}
```
You can cache prepared queries:
```ruby
require 'reactive-pg-client/pg_client'
# Enable prepare statements
options['cachePreparedStatements'] = true
client = ReactivePgClient::PgClient.pool(vertx, options)
```
You can fetch generated keys with a 'RETURNING' clause in your query:
```ruby
require 'reactive-pg-client/tuple'
client.prepared_query("INSERT INTO color (color_name) VALUES ($1), ($2), ($3) RETURNING color_id", ReactivePgClient::Tuple.of("white", "red", "blue")) { |ar_err,ar|
if (ar_err == nil)
rows = ar
puts rows.row_count()
rows.each do |row|
puts "generated key: #{row.get_integer("color_id")}"
end
else
puts "Failure: #{ar_err.get_message()}"
end
}
```
## Using connections
When you need to execute sequential queries (without a transaction), you can create a new connection
or borrow one from the pool:
```ruby
Code not translatable
```
Prepared queries can be created:
```ruby
require 'reactive-pg-client/tuple'
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1") { |ar1_err,ar1|
if (ar1_err == nil)
pq = ar1
pq.execute(ReactivePgClient::Tuple.of("julien")) { |ar2_err,ar2|
if (ar2_err == nil)
# All rows
rows = ar2
end
}
end
}
```
NOTE: prepared query caching depends on the [`cachePreparedStatements`](../dataobjects.html#PgConnectOptions#set_cache_prepared_statements-instance_method) and
does not depend on whether you are creating prepared queries or use [`direct prepared queries`](../../yardoc/ReactivePgClient/PgClient.html#prepared_query-instance_method)
[`PgPreparedQuery`](../../yardoc/ReactivePgClient/PgPreparedQuery.html)can perform efficient batching:
```ruby
require 'reactive-pg-client/tuple'
connection.prepare("INSERT INTO USERS (id, name) VALUES ($1, $2)") { |ar1_err,ar1|
if (ar1_err == nil)
prepared = ar1
# Create a query : bind parameters
batch = Array.new
# Add commands to the createBatch
batch.push(ReactivePgClient::Tuple.of("julien", "Julien Viet"))
batch.push(ReactivePgClient::Tuple.of("emad", "Emad Alblueshi"))
prepared.batch(batch) { |res_err,res|
if (res_err == nil)
# Process rows
rows = res
else
puts "Batch failed #{res_err}"
end
}
end
}
```
## Using transactions
### Transactions with connections
You can execute transaction using SQL `BEGIN`/`COMMIT`/`ROLLBACK`, if you do so you must use
a [`PgConnection`](../../yardoc/ReactivePgClient/PgConnection.html) and manage it yourself.
Or you can use the transaction API of [`PgConnection`](../../yardoc/ReactivePgClient/PgConnection.html):
```ruby
Code not translatable
```
When Postgres reports the current transaction is failed (e.g the infamous _current transaction is aborted, commands ignored until
end of transaction block_), the transaction is rollbacked and the [`abortHandler`](../../yardoc/ReactivePgClient/PgTransaction.html#abort_handler-instance_method)
is called:
```ruby
pool.get_connection() { |res_err,res|
if (res_err == nil)
# Transaction must use a connection
conn = res
# Begin the transaction
tx = conn.begin().abort_handler() { |v|
puts "Transaction failed => rollbacked"
}
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')") { |ar_err,ar|
# Works fine of course
if (ar_err == nil)
else
tx.rollback()
conn.close()
end
}
conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')") { |ar_err,ar|
# Fails and triggers transaction aborts
}
# Attempt to commit the transaction
tx.commit() { |ar_err,ar|
# But transaction abortion fails it
# Return the connection to the pool
conn.close()
}
end
}
```
### Simplified transaction API
When you use a pool, you can start a transaction directly on the pool.
It borrows a connection from the pool, begins the transaction and releases the connection to the pool when the transaction ends.
```ruby
Code not translatable
```
## Cursors and streaming
By default prepared query execution fetches all rows, you can use a
[`PgCursor`](../../yardoc/ReactivePgClient/PgCursor.html)to control the amount of rows you want to read:
```ruby
require 'reactive-pg-client/tuple'
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1") { |ar1_err,ar1|
if (ar1_err == nil)
pq = ar1
# Cursors require to run within a transaction
tx = connection.begin()
# Create a cursor
cursor = pq.cursor(ReactivePgClient::Tuple.of("julien"))
# Read 50 rows
cursor.read(50) { |ar2_err,ar2|
if (ar2_err == nil)
rows = ar2
# Check for more ?
if (cursor.has_more?())
# Repeat the process...
else
# No more rows - commit the transaction
tx.commit()
end
end
}
end
}
```
PostreSQL destroys cursors at the end of a transaction, so the cursor API shall be used
within a transaction, otherwise you will likely get the `34000` PostgreSQL error.
Cursors shall be closed when they are released prematurely:
```ruby
cursor.read(50) { |ar2_err,ar2|
if (ar2_err == nil)
# Close the cursor
cursor.close()
end
}
```
A stream API is also available for cursors, which can be more convenient, specially with the Rxified version.
```ruby
require 'reactive-pg-client/tuple'
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1") { |ar1_err,ar1|
if (ar1_err == nil)
pq = ar1
# Streams require to run within a transaction
tx = connection.begin()
# Fetch 50 rows at a time
stream = pq.create_stream(50, ReactivePgClient::Tuple.of("julien"))
# Use the stream
stream.exception_handler() { |err|
puts "Error: #{err.get_message()}"
}
stream.end_handler() { |v|
tx.commit()
puts "End of stream"
}
stream.handler() { |row|
puts "User: #{row.get_string("last_name")}"
}
end
}
```
The stream read the rows by batch of `50` and stream them, when the rows have been passed to the handler,
a new batch of `50` is read and so on.
The stream can be resumed or paused, the loaded rows will remain in memory until they are delivered and the cursor
will stop iterating.
## Postgres type mapping
Currently the client supports the following Postgres types
* BOOLEAN (`java.lang.Boolean`)
* INT2 (`java.lang.Short`)
* INT4 (`java.lang.Integer`)
* INT8 (`java.lang.Long`)
* FLOAT4 (`java.lang.Float`)
* FLOAT8 (`java.lang.Double`)
* CHAR (`java.lang.String`)
* VARCHAR (`java.lang.String`)
* TEXT (`java.lang.String`)
* ENUM (`java.lang.String`)
* NAME (`java.lang.String`)
* SERIAL2 (`java.lang.Short`)
* SERIAL4 (`java.lang.Integer`)
* SERIAL8 (`java.lang.Long`)
* NUMERIC (`io.reactiverse.pgclient.data.Numeric`)
* UUID (`java.util.UUID`)
* DATE (`java.time.LocalDate`)
* TIME (`java.time.LocalTime`)
* TIMETZ (`java.time.OffsetTime`)
* TIMESTAMP (`java.time.LocalDateTime`)
* TIMESTAMPTZ (`java.time.OffsetDateTime`)
* INTERVAL (`io.reactiverse.pgclient.data.Interval`)
* BYTEA (`io.vertx.core.buffer.Buffer`)
* JSON (`io.reactiverse.pgclient.data.Json`)
* JSONB (`io.reactiverse.pgclient.data.Json`)
* POINT (`io.reactiverse.pgclient.data.Point`)
* LINE (`io.reactiverse.pgclient.data.Line`)
* LSEG (`io.reactiverse.pgclient.data.LineSegment`)
* BOX (`io.reactiverse.pgclient.data.Box`)
* PATH (`io.reactiverse.pgclient.data.Path`)
* POLYGON (`io.reactiverse.pgclient.data.Polygon`)
* CIRCLE (`io.reactiverse.pgclient.data.Circle`)
Tuple decoding uses the above types when storing values, it also performs on the flu conversion the actual value when possible:
```ruby
pool.query("SELECT 1::BIGINT \"VAL\"") { |ar_err,ar|
rowSet = ar
row = rowSet.iterator().next()
# Stored as java.lang.Long
value = row.get_value(0)
# Convert to java.lang.Integer
intValue = row.get_integer(0)
}
```
Tuple encoding uses the above type mapping for encoding, unless the type is numeric in which case `java.lang.Number` is used instead:
```ruby
pool.query("SELECT 1::BIGINT \"VAL\"") { |ar_err,ar|
rowSet = ar
row = rowSet.iterator().next()
# Stored as java.lang.Long
value = row.get_value(0)
# Convert to java.lang.Integer
intValue = row.get_integer(0)
}
```
Arrays of these types are supported.
### Handling JSON
The [`Json`](../../yardoc/ReactivePgClient/Json.html) Java type is used to represent the Postgres `JSON` and `JSONB` type.
The main reason of this type is handling `null` JSON values.
```ruby
require 'reactive-pg-client/json'
require 'reactive-pg-client/tuple'
# Create a tuple
tuple = ReactivePgClient::Tuple.of(ReactivePgClient::Json.create(ReactivePgClient::Json.create(nil)), ReactivePgClient::Json.create(ReactivePgClient::Json.create({
'foo' => "bar"
})), ReactivePgClient::Json.create(ReactivePgClient::Json.create(nil)))
# Retrieving json
value = tuple.get_json(0).value()
#
value = tuple.get_json(1).value()
#
value = tuple.get_json(3).value()
```
### Handling NUMERIC
The [`Numeric`](unavailable) Java type is used to represent the Postgres `NUMERIC` type.
```ruby
numeric = row.get_numeric("value")
if (numeric.na_n?())
# Handle NaN
else
value = numeric.big_decimal_value()
end
```
## Handling arrays
Arrays are available on [`Tuple`](../../yardoc/ReactivePgClient/Tuple.html) and [`Row`](../../yardoc/ReactivePgClient/Row.html):
```ruby
Code not translatable
```
## Handling custom types
Strings are used to represent custom types, both sent to and returned from Postgres.
You can read from Postgres and get the custom type as a string
```ruby
require 'reactive-pg-client/tuple'
client.prepared_query("SELECT address, (address).city FROM address_book WHERE id=$1", ReactivePgClient::Tuple.of(3)) { |ar_err,ar|
if (ar_err == nil)
rows = ar
rows.each do |row|
puts "Full Address #{row.get_string(0)}, City #{row.get_string(1)}"
end
else
puts "Failure: #{ar_err.get_message()}"
end
}
```
You can also write to Postgres by providing a string
```ruby
require 'reactive-pg-client/tuple'
client.prepared_query("INSERT INTO address_book (id, address) VALUES ($1, $2)", ReactivePgClient::Tuple.of(3, "('Anytown', 'Second Ave', false)")) { |ar_err,ar|
if (ar_err == nil)
rows = ar
puts rows.row_count()
else
puts "Failure: #{ar_err.get_message()}"
end
}
```
## Collector queries
You can use Java collectors with the query API:
```ruby
Code not translatable
```
The collector processing must not keep a reference on the [`Row`](../../yardoc/ReactivePgClient/Row.html) as
there is a single row used for processing the entire set.
The Java `Collectors` provides many interesting predefined collectors, for example you can
create easily create a string directly from the row set:
```ruby
Code not translatable
```
## RxJava support
The rxified API supports RxJava 1 and RxJava 2, the following examples use RxJava 2.
Most asynchronous constructs are available as methods prefixed by `rx`:
```ruby
Code not translatable
```
### Streaming
RxJava 2 supports `Observable` and `Flowable` types, these are exposed using
the [`PgStream`](unavailable) that you can get
from a [`PgPreparedQuery`](unavailable):
```ruby
Code not translatable
```
The same example using `Flowable`:
```ruby
Code not translatable
```
### Transaction
The simplified transaction API allows to easily write transactional
asynchronous flows:
```ruby
Code not translatable
```
## Pub/sub
Postgres supports pub/sub communication channels.
You can set a [`notificationHandler`](../../yardoc/ReactivePgClient/PgConnection.html#notification_handler-instance_method) to receive
Postgres notifications:
```ruby
connection.notification_handler() { |notification|
puts "Received #{notification['payload']} on channel #{notification['channel']}"
}
connection.query("LISTEN some-channel") { |ar_err,ar|
puts "Subscribed to channel"
}
```
The [`PgSubscriber`](../../yardoc/ReactivePgClient/PgSubscriber.html) is a channel manager managing a single connection that
provides per channel subscription:
```ruby
require 'reactive-pg-client/pg_subscriber'
subscriber = ReactivePgClient::PgSubscriber.subscriber(vertx, {
'port' => 5432,
'host' => "the-host",
'database' => "the-db",
'user' => "user",
'password' => "secret"
})
# You can set the channel before connect
subscriber.channel("channel1").handler() { |payload|
puts "Received #{payload}"
}
subscriber.connect() { |ar_err,ar|
if (ar_err == nil)
# Or you can set the channel after connect
subscriber.channel("channel2").handler() { |payload|
puts "Received #{payload}"
}
end
}
```
The channel name that is given to the channel method will be the exact name of the channel as held by Postgres for sending
notifications. Note this is different than the representation of the channel name in SQL, and
internally [`PgSubscriber`](../../yardoc/ReactivePgClient/PgSubscriber.html) will prepare the submitted channel name as a quoted identifier:
```ruby
require 'reactive-pg-client/pg_subscriber'
subscriber = ReactivePgClient::PgSubscriber.subscriber(vertx, {
'port' => 5432,
'host' => "the-host",
'database' => "the-db",
'user' => "user",
'password' => "secret"
})
subscriber.connect() { |ar_err,ar|
if (ar_err == nil)
# Complex channel name - name in PostgreSQL requires a quoted ID
subscriber.channel("Complex.Channel.Name").handler() { |payload|
puts "Received #{payload}"
}
subscriber.channel("Complex.Channel.Name").subscribe_handler() { |subscribed|
subscriber.actual_connection().query("NOTIFY \"Complex.Channel.Name\", 'msg'") { |notified_err,notified|
puts "Notified \"Complex.Channel.Name\""
}
}
# PostgreSQL simple ID's are forced lower-case
subscriber.channel("simple_channel").handler() { |payload|
puts "Received #{payload}"
}
subscriber.channel("simple_channel").subscribe_handler() { |subscribed|
# The following simple channel identifier is forced to lower case
subscriber.actual_connection().query("NOTIFY Simple_CHANNEL, 'msg'") { |notified_err,notified|
puts "Notified simple_channel"
}
}
# The following channel name is longer than the current
# (NAMEDATALEN = 64) - 1 == 63 character limit and will be truncated
subscriber.channel("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbb").handler() { |payload|
puts "Received #{payload}"
}
end
}
```
You can provide a reconnect policy as a function that takes the number of `retries` as argument and returns an `amountOfTime`
value:
* when `amountOfTime < 0`: the subscriber is closed and there is no retry
* when `amountOfTime = 0`: the subscriber retries to connect immediately
* when `amountOfTime > 0`: the subscriber retries after `amountOfTime` milliseconds
```ruby
require 'reactive-pg-client/pg_subscriber'
subscriber = ReactivePgClient::PgSubscriber.subscriber(vertx, {
'port' => 5432,
'host' => "the-host",
'database' => "the-db",
'user' => "user",
'password' => "secret"
})
# Reconnect at most 10 times after 100 ms each
subscriber.reconnect_policy(lambda { |retries|
if (retries < 10)
return 100
else
return -1
end
})
```
The default policy is to not reconnect.
## Cancelling Request
Postgres supports cancellation of requests in progress. You can cancel inflight requests using [`cancelRequest`](../../yardoc/ReactivePgClient/PgConnection.html#cancel_request-instance_method). Cancelling a request opens a new connection to the server and cancels the request and then close the connection.
```ruby
connection.query("SELECT pg_sleep(20)") { |ar_err,ar|
if (ar_err == nil)
# imagine this is a long query and is still running
puts "Query success"
else
# the server will abort the current query after cancelling request
puts "Failed to query due to #{ar_err.get_message()}"
end
}
connection.cancel_request() { |ar_err,ar|
if (ar_err == nil)
puts "Cancelling request has been sent"
else
puts "Failed to send cancelling request"
end
}
```
> The cancellation signal might or might not have any effect — for example, if it arrives after the backend has finished processing the query, then it will have no effect. If the cancellation is effective, it results in the current command being terminated early with an error message.
More information can be found in the [official documentation](https://www.postgresql.org/docs/11/protocol-flow.html#id-1.10.5.7.9).
## Using SSL/TLS
To configure the client to use SSL connection, you can configure the [`PgConnectOptions`](../dataobjects.html#PgConnectOptions)
like a Vert.x `NetClient`.
All [SSL modes](https://www.postgresql.org/docs/current/libpq-ssl.html#LIBPQ-SSL-PROTECTION) are supported and you are able to configure `sslmode`. The client is in `DISABLE` SSL mode by default.
`ssl` parameter is kept as a mere shortcut for setting `sslmode`. `setSsl(true)` is equivalent to `setSslMode(VERIFY_CA)` and `setSsl(false)` is equivalent to `setSslMode(DISABLE)`.
```ruby
require 'reactive-pg-client/pg_client'
options = {
'port' => 5432,
'host' => "the-host",
'database' => "the-db",
'user' => "user",
'password' => "secret",
'sslMode' => "VERIFY_CA",
'pemTrustOptions' => {
'certPaths' => [
"/path/to/cert.pem"
]
}
}
ReactivePgClient::PgClient.connect(vertx, options) { |res_err,res|
if (res_err == nil)
# Connected with SSL
else
puts "Could not connect #{res_err}"
end
}
```
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#ssl).
## Using a proxy
You can also configure the client to use an HTTP/1.x CONNECT, SOCKS4a or SOCKS5 proxy.
More information can be found in the [Vert.x documentation](http://vertx.io/docs/vertx-core/java/#_using_a_proxy_for_client_connections).
================================================
FILE: docs/jsdoc/index.html
================================================
JSDoc: Home
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/json */
var utils = require('vertx-js/util/utils');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JJson = Java.type('io.reactiverse.pgclient.data.Json');
/**
@class
*/
var Json = function(j_val) {
var j_json = j_val;
var that = this;
var __super_create = this.create;
var __super_value = this.value;
/**
@public
@return {Object}
*/
this.value = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnTypeUnknown(j_json["value()"]()) ;
} else if (typeof __super_value != 'undefined') {
return __super_value.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_json;
};
Json._jclass = utils.getJavaClass("io.reactiverse.pgclient.data.Json");
Json._jtype = {accept: function(obj) {
return Json._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(Json.prototype, {});
Json.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
Json._create = function(jdel) {var obj = Object.create(Json.prototype, {});
Json.apply(obj, arguments);
return obj;
}
/**
@memberof module:reactive-pg-client-js/json
@param value {Object}
@return {Json}
*/
Json.create = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] !== 'function') {
return utils.convReturnVertxGen(Json, JJson["create(java.lang.Object)"](utils.convParamTypeUnknown(__args[0]))) ;
}else throw new TypeError('function invoked with invalid arguments');
};
module.exports = Json;
Begin a transaction and returns a PgTransaction for controlling and tracking
this transaction.
When the connection is explicitely closed, any inflight transaction is rollbacked.
Send a request cancellation message to tell the server to cancel processing request in this connection.
Note: Use this with caution because the cancellation signal may or may not have any effect.
Parameters:
Name
Type
Description
handler
function
the handler notified if cancelling request is sent
Set an handler called when the connection receives notification on a channel.
The handler is called with the PgNotification and has access to the channel name
and the notification payload.
Execute the prepared query with a cursor and createStream the result. The createStream opens a cursor
with a fetch size to fetch the results.
Note: this requires to be in a transaction, since cursors require it.
the actual connection to Postgres, it might be null
Type
PgConnection
channel(name) → {PgChannel}
Return a channel for the given name.
Parameters:
Name
Type
Description
name
string
the channel name This will be the name of the channel exactly as held by Postgres for sending notifications. Internally this name will be truncated to the Postgres identifier maxiumum length of (NAMEDATALEN = 64) - 1 == 63 characters, and prepared as a quoted identifier without unicode escape sequence support for use in LISTEN/UNLISTEN commands. Examples of channel names and corresponding NOTIFY commands:
when name == "the_channel": NOTIFY the_channel, 'msg', NOTIFY The_Channel, 'msg', or NOTIFY "the_channel", 'msg' succeed in delivering a message to the created channel
when name == "The_Channel": NOTIFY "The_Channel", 'msg', succeeds in delivering a message to the created channel
a reference to this, so the API can be used fluently
Type
PgSubscriber
reconnectPolicy(policy) → {PgSubscriber}
Set the reconnect policy that is executed when the subscriber is disconnected.
When the subscriber is disconnected, the policy function is called with the actual
number of retries and returns an amountOfTime value:
when amountOfTime < 0: the subscriber is closed and there is no retry
when amountOfTime == 0: the subscriber retries to connect immediately
when amountOfTime > 0: the subscriber retries after amountOfTime milliseconds
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_channel */
var utils = require('vertx-js/util/utils');
var ReadStream = require('vertx-js/read_stream');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgChannel = Java.type('io.reactiverse.pgclient.pubsub.PgChannel');
/**
@class
*/
var PgChannel = function(j_val) {
var j_pgChannel = j_val;
var that = this;
ReadStream.call(this, j_val);
var __super_fetch = this.fetch;
var __super_subscribeHandler = this.subscribeHandler;
var __super_handler = this.handler;
var __super_pause = this.pause;
var __super_resume = this.resume;
var __super_endHandler = this.endHandler;
var __super_exceptionHandler = this.exceptionHandler;
/**
@public
@param arg0 {number}
@return {ReadStream}
*/
this.fetch = function(arg0) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
j_pgChannel["fetch(long)"](__args[0]) ;
return that;
} else if (typeof __super_fetch != 'undefined') {
return __super_fetch.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Set an handler called when the the channel get subscribed.
@public
@param handler {function} the handler
@return {PgChannel} a reference to this, so the API can be used fluently
*/
this.subscribeHandler = function(handler) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgChannel["subscribeHandler(io.vertx.core.Handler)"](__args[0]) ;
return that;
} else if (typeof __super_subscribeHandler != 'undefined') {
return __super_subscribeHandler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Set or unset an handler to be called when a the channel is notified by Postgres.
<p/>
<ul>
<li>when the handler is set, the subscriber sends a <code>LISTEN</code> command if needed</li>
<li>when the handler is unset, the subscriber sends a <code>UNLISTEN</code> command if needed</li>
</ul>
@public
@param handler {function} the handler
@return {PgChannel} a reference to this, so the API can be used fluently
*/
this.handler = function(handler) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'function' || __args[0] == null)) {
j_pgChannel["handler(io.vertx.core.Handler)"](__args[0] == null ? null : function(jVal) {
__args[0](jVal);
}) ;
return that;
} else if (typeof __super_handler != 'undefined') {
return __super_handler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Pause the channel, all notifications are discarded.
@public
@return {PgChannel} a reference to this, so the API can be used fluently
*/
this.pause = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgChannel["pause()"]() ;
return that;
} else if (typeof __super_pause != 'undefined') {
return __super_pause.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Resume the channel.
@public
@return {PgChannel} a reference to this, so the API can be used fluently
*/
this.resume = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgChannel["resume()"]() ;
return that;
} else if (typeof __super_resume != 'undefined') {
return __super_resume.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Set an handler to be called when no more notifications will be received.
@public
@param endHandler {function} the handler
@return {PgChannel} a reference to this, so the API can be used fluently
*/
this.endHandler = function(endHandler) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'function' || __args[0] == null)) {
j_pgChannel["endHandler(io.vertx.core.Handler)"](__args[0]) ;
return that;
} else if (typeof __super_endHandler != 'undefined') {
return __super_endHandler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@param handler {function}
@return {PgChannel}
*/
this.exceptionHandler = function(handler) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'function' || __args[0] == null)) {
j_pgChannel["exceptionHandler(io.vertx.core.Handler)"](__args[0] == null ? null : function(jVal) {
__args[0](utils.convReturnThrowable(jVal));
}) ;
return that;
} else if (typeof __super_exceptionHandler != 'undefined') {
return __super_exceptionHandler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgChannel;
};
PgChannel._jclass = utils.getJavaClass("io.reactiverse.pgclient.pubsub.PgChannel");
PgChannel._jtype = {accept: function(obj) {
return PgChannel._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgChannel.prototype, {});
PgChannel.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgChannel._create = function(jdel) {var obj = Object.create(PgChannel.prototype, {});
PgChannel.apply(obj, arguments);
return obj;
}
module.exports = PgChannel;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_connection */
var utils = require('vertx-js/util/utils');
var PgClient = require('reactive-pg-client-js/pg_client');
var PgTransaction = require('reactive-pg-client-js/pg_transaction');
var Tuple = require('reactive-pg-client-js/tuple');
var PgPreparedQuery = require('reactive-pg-client-js/pg_prepared_query');
var PgRowSet = require('reactive-pg-client-js/pg_row_set');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgConnection = Java.type('io.reactiverse.pgclient.PgConnection');
var PgNotification = Java.type('io.reactiverse.pgclient.PgNotification');
/**
A connection to Postgres.
@class
*/
var PgConnection = function(j_val) {
var j_pgConnection = j_val;
var that = this;
PgClient.call(this, j_val);
var __super_prepare = this.prepare;
var __super_exceptionHandler = this.exceptionHandler;
var __super_closeHandler = this.closeHandler;
var __super_begin = this.begin;
var __super_notificationHandler = this.notificationHandler;
var __super_processId = this.processId;
var __super_secretKey = this.secretKey;
var __super_cancelRequest = this.cancelRequest;
var __super_isSSL = this.isSSL;
var __super_close = this.close;
var __super_preparedQuery = this.preparedQuery;
var __super_query = this.query;
var __super_preparedQuery = this.preparedQuery;
var __super_preparedBatch = this.preparedBatch;
/**
Create a prepared query.
@public
@param sql {string} the sql
@param handler {function} the handler notified with the prepared query asynchronously
@return {PgConnection}
*/
this.prepare = function(sql, handler) {
var __args = arguments;
if (__args.length === 2 && typeof __args[0] === 'string' && typeof __args[1] === 'function') {
j_pgConnection["prepare(java.lang.String,io.vertx.core.Handler)"](__args[0], function(ar) {
if (ar.succeeded()) {
__args[1](utils.convReturnVertxGen(PgPreparedQuery, ar.result()), null);
} else {
__args[1](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_prepare != 'undefined') {
return __super_prepare.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Set an handler called with connection errors.
@public
@param handler {function} the handler
@return {PgConnection} a reference to this, so the API can be used fluently
*/
this.exceptionHandler = function(handler) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgConnection["exceptionHandler(io.vertx.core.Handler)"](function(jVal) {
__args[0](utils.convReturnThrowable(jVal));
}) ;
return that;
} else if (typeof __super_exceptionHandler != 'undefined') {
return __super_exceptionHandler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Set an handler called when the connection is closed.
@public
@param handler {function} the handler
@return {PgConnection} a reference to this, so the API can be used fluently
*/
this.closeHandler = function(handler) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgConnection["closeHandler(io.vertx.core.Handler)"](__args[0]) ;
return that;
} else if (typeof __super_closeHandler != 'undefined') {
return __super_closeHandler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Begin a transaction and returns a {@link PgTransaction} for controlling and tracking
this transaction.
<p/>
When the connection is explicitely closed, any inflight transaction is rollbacked.
@public
@return {PgTransaction} the transaction instance
*/
this.begin = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnVertxGen(PgTransaction, j_pgConnection["begin()"]()) ;
} else if (typeof __super_begin != 'undefined') {
return __super_begin.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Set an handler called when the connection receives notification on a channel.
<p/>
The handler is called with the <a href="../../dataobjects.html#PgNotification">PgNotification</a> and has access to the channel name
and the notification payload.
@public
@param handler {function} the handler
@return {PgConnection} the transaction instance
*/
this.notificationHandler = function(handler) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgConnection["notificationHandler(io.vertx.core.Handler)"](function(jVal) {
__args[0](utils.convReturnDataObject(jVal));
}) ;
return that;
} else if (typeof __super_notificationHandler != 'undefined') {
return __super_notificationHandler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {number} The process ID of the target backend
*/
this.processId = function() {
var __args = arguments;
if (__args.length === 0) {
return j_pgConnection["processId()"]() ;
} else if (typeof __super_processId != 'undefined') {
return __super_processId.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {number} The secret key for the target backend
*/
this.secretKey = function() {
var __args = arguments;
if (__args.length === 0) {
return j_pgConnection["secretKey()"]() ;
} else if (typeof __super_secretKey != 'undefined') {
return __super_secretKey.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Send a request cancellation message to tell the server to cancel processing request in this connection.
<br>Note: Use this with caution because the cancellation signal may or may not have any effect.
@public
@param handler {function} the handler notified if cancelling request is sent
@return {PgConnection} a reference to this, so the API can be used fluently
*/
this.cancelRequest = function(handler) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
return utils.convReturnVertxGen(PgConnection, j_pgConnection["cancelRequest(io.vertx.core.Handler)"](function(ar) {
if (ar.succeeded()) {
__args[0](null, null);
} else {
__args[0](null, ar.cause());
}
})) ;
} else if (typeof __super_cancelRequest != 'undefined') {
return __super_cancelRequest.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {boolean} whether the connection uses SSL
*/
this.isSSL = function() {
var __args = arguments;
if (__args.length === 0) {
return j_pgConnection["isSSL()"]() ;
} else if (typeof __super_isSSL != 'undefined') {
return __super_isSSL.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Close the current connection after all the pending commands have been processed.
@public
*/
this.close = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgConnection["close()"]();
} else if (typeof __super_close != 'undefined') {
return __super_close.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@param sql {string}
@param arguments {Tuple}
@param handler {function}
@return {PgConnection}
*/
this.preparedQuery = function() {
var __args = arguments;
if (__args.length === 2 && typeof __args[0] === 'string' && typeof __args[1] === 'function') {
j_pgConnection["preparedQuery(java.lang.String,io.vertx.core.Handler)"](__args[0], function(ar) {
if (ar.succeeded()) {
__args[1](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[1](null, ar.cause());
}
}) ;
return that;
} else if (__args.length === 3 && typeof __args[0] === 'string' && typeof __args[1] === 'object' && __args[1]._jdel && typeof __args[2] === 'function') {
j_pgConnection["preparedQuery(java.lang.String,io.reactiverse.pgclient.Tuple,io.vertx.core.Handler)"](__args[0], __args[1]._jdel, function(ar) {
if (ar.succeeded()) {
__args[2](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[2](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_preparedQuery != 'undefined') {
return __super_preparedQuery.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@param sql {string}
@param handler {function}
@return {PgConnection}
*/
this.query = function(sql, handler) {
var __args = arguments;
if (__args.length === 2 && typeof __args[0] === 'string' && typeof __args[1] === 'function') {
j_pgConnection["query(java.lang.String,io.vertx.core.Handler)"](__args[0], function(ar) {
if (ar.succeeded()) {
__args[1](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[1](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_query != 'undefined') {
return __super_query.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@param sql {string}
@param batch {Array.<Tuple>}
@param handler {function}
@return {PgConnection}
*/
this.preparedBatch = function(sql, batch, handler) {
var __args = arguments;
if (__args.length === 3 && typeof __args[0] === 'string' && typeof __args[1] === 'object' && __args[1] instanceof Array && typeof __args[2] === 'function') {
j_pgConnection["preparedBatch(java.lang.String,java.util.List,io.vertx.core.Handler)"](__args[0], utils.convParamListVertxGen(__args[1]), function(ar) {
if (ar.succeeded()) {
__args[2](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[2](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_preparedBatch != 'undefined') {
return __super_preparedBatch.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgConnection;
};
PgConnection._jclass = utils.getJavaClass("io.reactiverse.pgclient.PgConnection");
PgConnection._jtype = {accept: function(obj) {
return PgConnection._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgConnection.prototype, {});
PgConnection.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgConnection._create = function(jdel) {var obj = Object.create(PgConnection.prototype, {});
PgConnection.apply(obj, arguments);
return obj;
}
module.exports = PgConnection;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_cursor */
var utils = require('vertx-js/util/utils');
var PgRowSet = require('reactive-pg-client-js/pg_row_set');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgCursor = Java.type('io.reactiverse.pgclient.PgCursor');
/**
A cursor that reads progressively the rows from Postgres, it is usefull for reading very large result.
@class
*/
var PgCursor = function(j_val) {
var j_pgCursor = j_val;
var that = this;
var __super_read = this.read;
var __super_hasMore = this.hasMore;
var __super_close = this.close;
var __super_close = this.close;
/**
Read rows from the cursor, the result is provided asynchronously to the <code>handler</code>.
@public
@param count {number} the amount of rows to read
@param handler {function} the handler for the result
*/
this.read = function(count, handler) {
var __args = arguments;
if (__args.length === 2 && typeof __args[0] ==='number' && typeof __args[1] === 'function') {
j_pgCursor["read(int,io.vertx.core.Handler)"](__args[0], function(ar) {
if (ar.succeeded()) {
__args[1](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[1](null, ar.cause());
}
});
} else if (typeof __super_read != 'undefined') {
return __super_read.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Returns <code>true</code> when the cursor has results in progress and the should be called to retrieve
them.
@public
@return {boolean} whether the cursor has more results,
*/
this.hasMore = function() {
var __args = arguments;
if (__args.length === 0) {
return j_pgCursor["hasMore()"]() ;
} else if (typeof __super_hasMore != 'undefined') {
return __super_hasMore.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Like {@link PgCursor#close} but with a <code>completionHandler</code> called when the cursor has been released.
@public
@param completionHandler {function}
*/
this.close = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgCursor["close()"]();
} else if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgCursor["close(io.vertx.core.Handler)"](function(ar) {
if (ar.succeeded()) {
__args[0](null, null);
} else {
__args[0](null, ar.cause());
}
});
} else if (typeof __super_close != 'undefined') {
return __super_close.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgCursor;
};
PgCursor._jclass = utils.getJavaClass("io.reactiverse.pgclient.PgCursor");
PgCursor._jtype = {accept: function(obj) {
return PgCursor._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgCursor.prototype, {});
PgCursor.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgCursor._create = function(jdel) {var obj = Object.create(PgCursor.prototype, {});
PgCursor.apply(obj, arguments);
return obj;
}
module.exports = PgCursor;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_iterator */
var utils = require('vertx-js/util/utils');
var Row = require('reactive-pg-client-js/row');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgIterator = Java.type('io.reactiverse.pgclient.PgIterator');
/**
An iterator for processing postgres items synchronously.
@class
*/
var PgIterator = function(j_val) {
var j_pgIterator = j_val;
var that = this;
var __super_hasNext = this.hasNext;
var __super_next = this.next;
/**
@public
@return {boolean}
*/
this.hasNext = function() {
var __args = arguments;
if (__args.length === 0) {
return j_pgIterator["hasNext()"]() ;
} else if (typeof __super_hasNext != 'undefined') {
return __super_hasNext.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {Row}
*/
this.next = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnVertxGen(Row, j_pgIterator["next()"]()) ;
} else if (typeof __super_next != 'undefined') {
return __super_next.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgIterator;
};
PgIterator._jclass = utils.getJavaClass("io.reactiverse.pgclient.PgIterator");
PgIterator._jtype = {accept: function(obj) {
return PgIterator._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgIterator.prototype, {});
PgIterator.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgIterator._create = function(jdel) {var obj = Object.create(PgIterator.prototype, {});
PgIterator.apply(obj, arguments);
return obj;
}
module.exports = PgIterator;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_pool */
var utils = require('vertx-js/util/utils');
var PgClient = require('reactive-pg-client-js/pg_client');
var PgTransaction = require('reactive-pg-client-js/pg_transaction');
var Tuple = require('reactive-pg-client-js/tuple');
var PgConnection = require('reactive-pg-client-js/pg_connection');
var PgRowSet = require('reactive-pg-client-js/pg_row_set');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgPool = Java.type('io.reactiverse.pgclient.PgPool');
/**
A pool of connection.
@class
*/
var PgPool = function(j_val) {
var j_pgPool = j_val;
var that = this;
PgClient.call(this, j_val);
var __super_preparedQuery = this.preparedQuery;
var __super_query = this.query;
var __super_preparedQuery = this.preparedQuery;
var __super_preparedBatch = this.preparedBatch;
var __super_getConnection = this.getConnection;
var __super_begin = this.begin;
var __super_close = this.close;
/**
@public
@param sql {string}
@param arguments {Tuple}
@param handler {function}
@return {PgPool}
*/
this.preparedQuery = function() {
var __args = arguments;
if (__args.length === 2 && typeof __args[0] === 'string' && typeof __args[1] === 'function') {
j_pgPool["preparedQuery(java.lang.String,io.vertx.core.Handler)"](__args[0], function(ar) {
if (ar.succeeded()) {
__args[1](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[1](null, ar.cause());
}
}) ;
return that;
} else if (__args.length === 3 && typeof __args[0] === 'string' && typeof __args[1] === 'object' && __args[1]._jdel && typeof __args[2] === 'function') {
j_pgPool["preparedQuery(java.lang.String,io.reactiverse.pgclient.Tuple,io.vertx.core.Handler)"](__args[0], __args[1]._jdel, function(ar) {
if (ar.succeeded()) {
__args[2](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[2](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_preparedQuery != 'undefined') {
return __super_preparedQuery.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@param sql {string}
@param handler {function}
@return {PgPool}
*/
this.query = function(sql, handler) {
var __args = arguments;
if (__args.length === 2 && typeof __args[0] === 'string' && typeof __args[1] === 'function') {
j_pgPool["query(java.lang.String,io.vertx.core.Handler)"](__args[0], function(ar) {
if (ar.succeeded()) {
__args[1](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[1](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_query != 'undefined') {
return __super_query.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@param sql {string}
@param batch {Array.<Tuple>}
@param handler {function}
@return {PgPool}
*/
this.preparedBatch = function(sql, batch, handler) {
var __args = arguments;
if (__args.length === 3 && typeof __args[0] === 'string' && typeof __args[1] === 'object' && __args[1] instanceof Array && typeof __args[2] === 'function') {
j_pgPool["preparedBatch(java.lang.String,java.util.List,io.vertx.core.Handler)"](__args[0], utils.convParamListVertxGen(__args[1]), function(ar) {
if (ar.succeeded()) {
__args[2](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[2](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_preparedBatch != 'undefined') {
return __super_preparedBatch.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a connection from the pool.
@public
@param handler {function} the handler that will get the connection result
*/
this.getConnection = function(handler) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgPool["getConnection(io.vertx.core.Handler)"](function(ar) {
if (ar.succeeded()) {
__args[0](utils.convReturnVertxGen(PgConnection, ar.result()), null);
} else {
__args[0](null, ar.cause());
}
});
} else if (typeof __super_getConnection != 'undefined') {
return __super_getConnection.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Borrow a connection from the pool and begin a transaction, the underlying connection will be returned
to the pool when the transaction ends.
@public
@param handler {function}
*/
this.begin = function(handler) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgPool["begin(io.vertx.core.Handler)"](function(ar) {
if (ar.succeeded()) {
__args[0](utils.convReturnVertxGen(PgTransaction, ar.result()), null);
} else {
__args[0](null, ar.cause());
}
});
} else if (typeof __super_begin != 'undefined') {
return __super_begin.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Close the pool and release the associated resources.
@public
*/
this.close = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgPool["close()"]();
} else if (typeof __super_close != 'undefined') {
return __super_close.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgPool;
};
PgPool._jclass = utils.getJavaClass("io.reactiverse.pgclient.PgPool");
PgPool._jtype = {accept: function(obj) {
return PgPool._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgPool.prototype, {});
PgPool.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgPool._create = function(jdel) {var obj = Object.create(PgPool.prototype, {});
PgPool.apply(obj, arguments);
return obj;
}
module.exports = PgPool;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_prepared_query */
var utils = require('vertx-js/util/utils');
var Row = require('reactive-pg-client-js/row');
var Tuple = require('reactive-pg-client-js/tuple');
var PgCursor = require('reactive-pg-client-js/pg_cursor');
var PgRowSet = require('reactive-pg-client-js/pg_row_set');
var PgStream = require('reactive-pg-client-js/pg_stream');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgPreparedQuery = Java.type('io.reactiverse.pgclient.PgPreparedQuery');
/**
A prepared query.
@class
*/
var PgPreparedQuery = function(j_val) {
var j_pgPreparedQuery = j_val;
var that = this;
var __super_execute = this.execute;
var __super_execute = this.execute;
var __super_cursor = this.cursor;
var __super_cursor = this.cursor;
var __super_createStream = this.createStream;
var __super_batch = this.batch;
var __super_close = this.close;
var __super_close = this.close;
/**
Create a cursor with the provided <code>arguments</code>.
@public
@param args {Tuple} the list of arguments
@param handler {function}
@return {PgPreparedQuery} the query
*/
this.execute = function() {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgPreparedQuery["execute(io.vertx.core.Handler)"](function(ar) {
if (ar.succeeded()) {
__args[0](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[0](null, ar.cause());
}
}) ;
return that;
} else if (__args.length === 2 && typeof __args[0] === 'object' && __args[0]._jdel && typeof __args[1] === 'function') {
j_pgPreparedQuery["execute(io.reactiverse.pgclient.Tuple,io.vertx.core.Handler)"](__args[0]._jdel, function(ar) {
if (ar.succeeded()) {
__args[1](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[1](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_execute != 'undefined') {
return __super_execute.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Create a cursor with the provided <code>arguments</code>.
@public
@param args {Tuple} the list of arguments
@return {PgCursor} the query
*/
this.cursor = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnVertxGen(PgCursor, j_pgPreparedQuery["cursor()"]()) ;
} else if (__args.length === 1 && typeof __args[0] === 'object' && __args[0]._jdel) {
return utils.convReturnVertxGen(PgCursor, j_pgPreparedQuery["cursor(io.reactiverse.pgclient.Tuple)"](__args[0]._jdel)) ;
} else if (typeof __super_cursor != 'undefined') {
return __super_cursor.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Execute the prepared query with a cursor and createStream the result. The createStream opens a cursor
with a <code>fetch</code> size to fetch the results.
<p/>
Note: this requires to be in a transaction, since cursors require it.
@public
@param fetch {number} the cursor fetch size
@param args {Tuple} the prepared query arguments
@return {PgStream} the createStream
*/
this.createStream = function(fetch, args) {
var __args = arguments;
if (__args.length === 2 && typeof __args[0] ==='number' && typeof __args[1] === 'object' && __args[1]._jdel) {
return utils.convReturnVertxGen(PgStream, j_pgPreparedQuery["createStream(int,io.reactiverse.pgclient.Tuple)"](__args[0], __args[1]._jdel), Row._jtype) ;
} else if (typeof __super_createStream != 'undefined') {
return __super_createStream.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Execute a batch.
@public
@param argsList {Array.<Tuple>} the list of tuple for the batch
@param handler {function}
@return {PgPreparedQuery} the createBatch
*/
this.batch = function(argsList, handler) {
var __args = arguments;
if (__args.length === 2 && typeof __args[0] === 'object' && __args[0] instanceof Array && typeof __args[1] === 'function') {
j_pgPreparedQuery["batch(java.util.List,io.vertx.core.Handler)"](utils.convParamListVertxGen(__args[0]), function(ar) {
if (ar.succeeded()) {
__args[1](utils.convReturnVertxGen(PgRowSet, ar.result()), null);
} else {
__args[1](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_batch != 'undefined') {
return __super_batch.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Like {@link PgPreparedQuery#close} but notifies the <code>completionHandler</code> when it's closed.
@public
@param completionHandler {function}
*/
this.close = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgPreparedQuery["close()"]();
} else if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgPreparedQuery["close(io.vertx.core.Handler)"](function(ar) {
if (ar.succeeded()) {
__args[0](null, null);
} else {
__args[0](null, ar.cause());
}
});
} else if (typeof __super_close != 'undefined') {
return __super_close.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgPreparedQuery;
};
PgPreparedQuery._jclass = utils.getJavaClass("io.reactiverse.pgclient.PgPreparedQuery");
PgPreparedQuery._jtype = {accept: function(obj) {
return PgPreparedQuery._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgPreparedQuery.prototype, {});
PgPreparedQuery.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgPreparedQuery._create = function(jdel) {var obj = Object.create(PgPreparedQuery.prototype, {});
PgPreparedQuery.apply(obj, arguments);
return obj;
}
module.exports = PgPreparedQuery;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_result */
var utils = require('vertx-js/util/utils');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgResult = Java.type('io.reactiverse.pgclient.PgResult');
/**
Represents the result of an operation on database.
@class
*/
var PgResult = function(j_val, j_arg_0) {
var j_pgResult = j_val;
var that = this;
var j_T = typeof j_arg_0 !== 'undefined' ? j_arg_0 : utils.unknown_jtype;
var __super_rowCount = this.rowCount;
var __super_columnsNames = this.columnsNames;
var __super_size = this.size;
var __super_value = this.value;
var __super_next = this.next;
/**
Get the number of the affected rows in the operation to this PgResult.
<p/>
The meaning depends on the executed statement:
<ul>
<li>INSERT: the number of rows inserted</li>
<li>DELETE: the number of rows deleted</li>
<li>UPDATE: the number of rows updated</li>
<li>SELECT: the number of rows retrieved</li>
</ul>
@public
@return {number} the count of affected rows.
*/
this.rowCount = function() {
var __args = arguments;
if (__args.length === 0) {
return j_pgResult["rowCount()"]() ;
} else if (typeof __super_rowCount != 'undefined') {
return __super_rowCount.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get the names of columns in the PgResult.
@public
@return {Array.<string>} the list of names of columns.
*/
this.columnsNames = function() {
var __args = arguments;
if (__args.length === 0) {
return j_pgResult["columnsNames()"]() ;
} else if (typeof __super_columnsNames != 'undefined') {
return __super_columnsNames.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get the number of rows in the PgResult.
@public
@return {number} the count of rows.
*/
this.size = function() {
var __args = arguments;
if (__args.length === 0) {
return j_pgResult["size()"]() ;
} else if (typeof __super_size != 'undefined') {
return __super_size.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get the result value.
@public
@return {Object} the result
*/
this.value = function() {
var __args = arguments;
if (__args.length === 0) {
return j_T.wrap(j_pgResult["value()"]()) ;
} else if (typeof __super_value != 'undefined') {
return __super_value.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Return the next available result or <code>null</code>, e.g for a simple query that executed multiple queries or for
a batch result.
@public
@return {PgResult} the next available result or <code>null</code> if none is available
*/
this.next = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnVertxGen(PgResult, j_pgResult["next()"](), undefined) ;
} else if (typeof __super_next != 'undefined') {
return __super_next.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgResult;
};
PgResult._jclass = utils.getJavaClass("io.reactiverse.pgclient.PgResult");
PgResult._jtype = {accept: function(obj) {
return PgResult._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgResult.prototype, {});
PgResult.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgResult._create = function(jdel) {var obj = Object.create(PgResult.prototype, {});
PgResult.apply(obj, arguments);
return obj;
}
module.exports = PgResult;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_row_set */
var utils = require('vertx-js/util/utils');
var PgIterator = require('reactive-pg-client-js/pg_iterator');
var Row = require('reactive-pg-client-js/row');
var PgResult = require('reactive-pg-client-js/pg_result');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgRowSet = Java.type('io.reactiverse.pgclient.PgRowSet');
/**
A set of rows.
@class
*/
var PgRowSet = function(j_val) {
var j_pgRowSet = j_val;
var that = this;
PgResult.call(this, j_val, PgRowSet._jtype);
var __super_value = this.value;
var __super_iterator = this.iterator;
var __super_next = this.next;
/**
Get the result value.
@public
@return {PgRowSet} the result
*/
this.value = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnVertxGen(PgRowSet, j_pgRowSet["value()"]()) ;
} else if (typeof __super_value != 'undefined') {
return __super_value.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {PgIterator}
*/
this.iterator = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnVertxGen(PgIterator, j_pgRowSet["iterator()"]()) ;
} else if (typeof __super_iterator != 'undefined') {
return __super_iterator.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {PgRowSet}
*/
this.next = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnVertxGen(PgRowSet, j_pgRowSet["next()"]()) ;
} else if (typeof __super_next != 'undefined') {
return __super_next.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgRowSet;
};
PgRowSet._jclass = utils.getJavaClass("io.reactiverse.pgclient.PgRowSet");
PgRowSet._jtype = {accept: function(obj) {
return PgRowSet._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgRowSet.prototype, {});
PgRowSet.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgRowSet._create = function(jdel) {var obj = Object.create(PgRowSet.prototype, {});
PgRowSet.apply(obj, arguments);
return obj;
}
module.exports = PgRowSet;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_stream */
var utils = require('vertx-js/util/utils');
var ReadStream = require('vertx-js/read_stream');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgStream = Java.type('io.reactiverse.pgclient.PgStream');
/**
A row oriented stream.
@class
*/
var PgStream = function(j_val, j_arg_0) {
var j_pgStream = j_val;
var that = this;
var j_T = typeof j_arg_0 !== 'undefined' ? j_arg_0 : utils.unknown_jtype;ReadStream.call(this, j_val);
var __super_fetch = this.fetch;
var __super_exceptionHandler = this.exceptionHandler;
var __super_handler = this.handler;
var __super_pause = this.pause;
var __super_resume = this.resume;
var __super_endHandler = this.endHandler;
var __super_close = this.close;
var __super_close = this.close;
/**
@public
@param arg0 {number}
@return {ReadStream}
*/
this.fetch = function(arg0) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
j_pgStream["fetch(long)"](__args[0]) ;
return that;
} else if (typeof __super_fetch != 'undefined') {
return __super_fetch.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@param handler {function}
@return {PgStream}
*/
this.exceptionHandler = function(handler) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'function' || __args[0] == null)) {
j_pgStream["exceptionHandler(io.vertx.core.Handler)"](__args[0] == null ? null : function(jVal) {
__args[0](utils.convReturnThrowable(jVal));
}) ;
return that;
} else if (typeof __super_exceptionHandler != 'undefined') {
return __super_exceptionHandler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@param handler {function}
@return {PgStream}
*/
this.handler = function(handler) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'function' || __args[0] == null)) {
j_pgStream["handler(io.vertx.core.Handler)"](__args[0] == null ? null : function(jVal) {
__args[0](j_T.wrap(jVal));
}) ;
return that;
} else if (typeof __super_handler != 'undefined') {
return __super_handler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {PgStream}
*/
this.pause = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgStream["pause()"]() ;
return that;
} else if (typeof __super_pause != 'undefined') {
return __super_pause.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {PgStream}
*/
this.resume = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgStream["resume()"]() ;
return that;
} else if (typeof __super_resume != 'undefined') {
return __super_resume.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@param endHandler {function}
@return {PgStream}
*/
this.endHandler = function(endHandler) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'function' || __args[0] == null)) {
j_pgStream["endHandler(io.vertx.core.Handler)"](__args[0]) ;
return that;
} else if (typeof __super_endHandler != 'undefined') {
return __super_endHandler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Close the stream and release the resources.
@public
@param completionHandler {function} the completion handler for this operation
*/
this.close = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgStream["close()"]();
} else if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgStream["close(io.vertx.core.Handler)"](function(ar) {
if (ar.succeeded()) {
__args[0](null, null);
} else {
__args[0](null, ar.cause());
}
});
} else if (typeof __super_close != 'undefined') {
return __super_close.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgStream;
};
PgStream._jclass = utils.getJavaClass("io.reactiverse.pgclient.PgStream");
PgStream._jtype = {accept: function(obj) {
return PgStream._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgStream.prototype, {});
PgStream.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgStream._create = function(jdel) {var obj = Object.create(PgStream.prototype, {});
PgStream.apply(obj, arguments);
return obj;
}
module.exports = PgStream;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/pg_subscriber */
var utils = require('vertx-js/util/utils');
var Vertx = require('vertx-js/vertx');
var PgConnection = require('reactive-pg-client-js/pg_connection');
var PgChannel = require('reactive-pg-client-js/pg_channel');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JPgSubscriber = Java.type('io.reactiverse.pgclient.pubsub.PgSubscriber');
var PgConnectOptions = Java.type('io.reactiverse.pgclient.PgConnectOptions');
/**
@class
*/
var PgSubscriber = function(j_val) {
var j_pgSubscriber = j_val;
var that = this;
var __super_subscriber = this.subscriber;
var __super_channel = this.channel;
var __super_connect = this.connect;
var __super_reconnectPolicy = this.reconnectPolicy;
var __super_closeHandler = this.closeHandler;
var __super_actualConnection = this.actualConnection;
var __super_closed = this.closed;
var __super_close = this.close;
/**
Return a channel for the given <code>name</code>.
@public
@param name {string} the channel name <p/> This will be the name of the channel exactly as held by Postgres for sending notifications. Internally this name will be truncated to the Postgres identifier maxiumum length of <code>(NAMEDATALEN = 64) - 1 == 63</code> characters, and prepared as a quoted identifier without unicode escape sequence support for use in <code>LISTEN/UNLISTEN</code> commands. Examples of channel names and corresponding <code>NOTIFY</code> commands: <ul> <li>when <code>name == "the_channel"</code>: <code>NOTIFY the_channel, 'msg'</code>, <code>NOTIFY The_Channel, 'msg'</code>, or <code>NOTIFY "the_channel", 'msg'</code> succeed in delivering a message to the created channel </li> <li>when <code>name == "The_Channel"</code>: <code>NOTIFY "The_Channel", 'msg'</code>, succeeds in delivering a message to the created channel </li> <li></li> </ul>
@return {PgChannel} the channel
*/
this.channel = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnVertxGen(PgChannel, j_pgSubscriber["channel(java.lang.String)"](__args[0])) ;
} else if (typeof __super_channel != 'undefined') {
return __super_channel.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Connect the subscriber to Postgres.
@public
@param handler {function} the handler notified of the connection success or failure
@return {PgSubscriber} a reference to this, so the API can be used fluently
*/
this.connect = function(handler) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgSubscriber["connect(io.vertx.core.Handler)"](function(ar) {
if (ar.succeeded()) {
__args[0](null, null);
} else {
__args[0](null, ar.cause());
}
}) ;
return that;
} else if (typeof __super_connect != 'undefined') {
return __super_connect.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Set the reconnect policy that is executed when the subscriber is disconnected.
<p/>
When the subscriber is disconnected, the <code>policy</code> function is called with the actual
number of retries and returns an <code>amountOfTime</code> value:
<ul>
<li>when <code>amountOfTime < 0</code>: the subscriber is closed and there is no retry</li>
<li>when <code>amountOfTime == 0</code>: the subscriber retries to connect immediately</li>
<li>when <code>amountOfTime > 0</code>: the subscriber retries after <code>amountOfTime</code> milliseconds</li>
</ul>
<p/>
The default policy does not perform any retries.
@public
@param policy {function} the policy to set
@return {PgSubscriber} a reference to this, so the API can be used fluently
*/
this.reconnectPolicy = function(policy) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgSubscriber["reconnectPolicy(java.util.function.Function)"](function(jVal) {
var jRet = __args[0](jVal);
return utils.convParamLong(jRet);
}) ;
return that;
} else if (typeof __super_reconnectPolicy != 'undefined') {
return __super_reconnectPolicy.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Set an handler called when the subscriber is closed.
@public
@param handler {function} the handler
@return {PgSubscriber} a reference to this, so the API can be used fluently
*/
this.closeHandler = function(handler) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'function') {
j_pgSubscriber["closeHandler(io.vertx.core.Handler)"](__args[0]) ;
return that;
} else if (typeof __super_closeHandler != 'undefined') {
return __super_closeHandler.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {PgConnection} the actual connection to Postgres, it might be <code>null</code>
*/
this.actualConnection = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnVertxGen(PgConnection, j_pgSubscriber["actualConnection()"]()) ;
} else if (typeof __super_actualConnection != 'undefined') {
return __super_actualConnection.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {boolean} whether the subscriber is closed
*/
this.closed = function() {
var __args = arguments;
if (__args.length === 0) {
return j_pgSubscriber["closed()"]() ;
} else if (typeof __super_closed != 'undefined') {
return __super_closed.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Close the subscriber, the retry policy will not be invoked.
@public
*/
this.close = function() {
var __args = arguments;
if (__args.length === 0) {
j_pgSubscriber["close()"]();
} else if (typeof __super_close != 'undefined') {
return __super_close.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_pgSubscriber;
};
PgSubscriber._jclass = utils.getJavaClass("io.reactiverse.pgclient.pubsub.PgSubscriber");
PgSubscriber._jtype = {accept: function(obj) {
return PgSubscriber._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(PgSubscriber.prototype, {});
PgSubscriber.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
PgSubscriber._create = function(jdel) {var obj = Object.create(PgSubscriber.prototype, {});
PgSubscriber.apply(obj, arguments);
return obj;
}
/**
Create a subscriber.
@memberof module:reactive-pg-client-js/pg_subscriber
@param vertx {Vertx} the vertx instance
@param options {Object} the connect options
@return {PgSubscriber} the subscriber
*/
PgSubscriber.subscriber = function(vertx, options) {
var __args = arguments;
if (__args.length === 2 && typeof __args[0] === 'object' && __args[0]._jdel && (typeof __args[1] === 'object' && __args[1] != null)) {
return utils.convReturnVertxGen(PgSubscriber, JPgSubscriber["subscriber(io.vertx.core.Vertx,io.reactiverse.pgclient.PgConnectOptions)"](__args[0]._jdel, __args[1] != null ? new PgConnectOptions(new JsonObject(Java.asJSONCompatible(__args[1]))) : null)) ;
}else throw new TypeError('function invoked with invalid arguments');
};
module.exports = PgSubscriber;
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/row */
var utils = require('vertx-js/util/utils');
var Json = require('reactive-pg-client-js/json');
var Buffer = require('vertx-js/buffer');
var Tuple = require('reactive-pg-client-js/tuple');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JRow = Java.type('io.reactiverse.pgclient.Row');
var Point = Java.type('io.reactiverse.pgclient.data.Point');
var Path = Java.type('io.reactiverse.pgclient.data.Path');
var Box = Java.type('io.reactiverse.pgclient.data.Box');
var Circle = Java.type('io.reactiverse.pgclient.data.Circle');
var Polygon = Java.type('io.reactiverse.pgclient.data.Polygon');
var Interval = Java.type('io.reactiverse.pgclient.data.Interval');
var LineSegment = Java.type('io.reactiverse.pgclient.data.LineSegment');
var Line = Java.type('io.reactiverse.pgclient.data.Line');
/**
@class
*/
var Row = function(j_val) {
var j_row = j_val;
var that = this;
Tuple.call(this, j_val);
var __super_getColumnName = this.getColumnName;
var __super_getBoolean = this.getBoolean;
var __super_getValue = this.getValue;
var __super_getShort = this.getShort;
var __super_getInteger = this.getInteger;
var __super_getLong = this.getLong;
var __super_getFloat = this.getFloat;
var __super_getDouble = this.getDouble;
var __super_getString = this.getString;
var __super_getJson = this.getJson;
var __super_getBuffer = this.getBuffer;
var __super_getPoint = this.getPoint;
var __super_getLine = this.getLine;
var __super_getLineSegment = this.getLineSegment;
var __super_getBox = this.getBox;
var __super_getPath = this.getPath;
var __super_getPolygon = this.getPolygon;
var __super_getCircle = this.getCircle;
var __super_getInterval = this.getInterval;
/**
Get a column name at <code>pos</code>.
@public
@param pos {number} the position
@return {string} the column name or <code>null</code>
*/
this.getColumnName = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return j_row["getColumnName(int)"](__args[0]) ;
} else if (typeof __super_getColumnName != 'undefined') {
return __super_getColumnName.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a boolean value at <code>pos</code>.
@public
@param name {string} the column
@return {boolean} the value or <code>null</code>
*/
this.getBoolean = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return j_row["getBoolean(java.lang.String)"](__args[0]) ;
} else if (typeof __super_getBoolean != 'undefined') {
return __super_getBoolean.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get an object value at <code>pos</code>.
@public
@param name {string} the column
@return {Object} the value or <code>null</code>
*/
this.getValue = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnTypeUnknown(j_row["getValue(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getValue != 'undefined') {
return __super_getValue.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a short value at <code>pos</code>.
@public
@param name {string} the column
@return {number} the value or <code>null</code>
*/
this.getShort = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return j_row["getShort(java.lang.String)"](__args[0]) ;
} else if (typeof __super_getShort != 'undefined') {
return __super_getShort.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get an integer value at <code>pos</code>.
@public
@param name {string} the column
@return {number} the value or <code>null</code>
*/
this.getInteger = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return j_row["getInteger(java.lang.String)"](__args[0]) ;
} else if (typeof __super_getInteger != 'undefined') {
return __super_getInteger.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a long value at <code>pos</code>.
@public
@param name {string} the column
@return {number} the value or <code>null</code>
*/
this.getLong = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnLong(j_row["getLong(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getLong != 'undefined') {
return __super_getLong.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a float value at <code>pos</code>.
@public
@param name {string} the column
@return {number} the value or <code>null</code>
*/
this.getFloat = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return j_row["getFloat(java.lang.String)"](__args[0]) ;
} else if (typeof __super_getFloat != 'undefined') {
return __super_getFloat.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a double value at <code>pos</code>.
@public
@param name {string} the column
@return {number} the value or <code>null</code>
*/
this.getDouble = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return j_row["getDouble(java.lang.String)"](__args[0]) ;
} else if (typeof __super_getDouble != 'undefined') {
return __super_getDouble.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a string value at <code>pos</code>.
@public
@param name {string} the column
@return {string} the value or <code>null</code>
*/
this.getString = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return j_row["getString(java.lang.String)"](__args[0]) ;
} else if (typeof __super_getString != 'undefined') {
return __super_getString.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a json value at <code>pos</code>.
@public
@param name {string} the column
@return {Json} the value or <code>null</code>
*/
this.getJson = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnVertxGen(Json, j_row["getJson(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getJson != 'undefined') {
return __super_getJson.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a buffer value at <code>pos</code>.
@public
@param name {string} the column
@return {Buffer} the value or <code>null</code>
*/
this.getBuffer = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnVertxGen(Buffer, j_row["getBuffer(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getBuffer != 'undefined') {
return __super_getBuffer.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param name {string} the column
@return {Object} the value or <code>null</code>
*/
this.getPoint = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnDataObject(j_row["getPoint(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getPoint != 'undefined') {
return __super_getPoint.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param name {string} the column
@return {Object} the value or <code>null</code>
*/
this.getLine = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnDataObject(j_row["getLine(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getLine != 'undefined') {
return __super_getLine.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param name {string} the column
@return {Object} the value or <code>null</code>
*/
this.getLineSegment = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnDataObject(j_row["getLineSegment(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getLineSegment != 'undefined') {
return __super_getLineSegment.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param name {string} the column
@return {Object} the value or <code>null</code>
*/
this.getBox = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnDataObject(j_row["getBox(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getBox != 'undefined') {
return __super_getBox.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param name {string} the column
@return {Object} the value or <code>null</code>
*/
this.getPath = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnDataObject(j_row["getPath(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getPath != 'undefined') {
return __super_getPath.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param name {string} the column
@return {Object} the value or <code>null</code>
*/
this.getPolygon = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnDataObject(j_row["getPolygon(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getPolygon != 'undefined') {
return __super_getPolygon.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param name {string} the column
@return {Object} the value or <code>null</code>
*/
this.getCircle = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnDataObject(j_row["getCircle(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getCircle != 'undefined') {
return __super_getCircle.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param name {string} the column
@return {Object} the value or <code>null</code>
*/
this.getInterval = function(name) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
return utils.convReturnDataObject(j_row["getInterval(java.lang.String)"](__args[0])) ;
} else if (typeof __super_getInterval != 'undefined') {
return __super_getInterval.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_row;
};
Row._jclass = utils.getJavaClass("io.reactiverse.pgclient.Row");
Row._jtype = {accept: function(obj) {
return Row._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(Row.prototype, {});
Row.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
Row._create = function(jdel) {var obj = Object.create(Row.prototype, {});
Row.apply(obj, arguments);
return obj;
}
module.exports = Row;
================================================
FILE: docs/jsdoc/scripts/linenumber.js
================================================
/*global document */
(function() {
var source = document.getElementsByClassName('prettyprint source linenums');
var i = 0;
var lineNumber = 0;
var lineId;
var lines;
var totalLines;
var anchorHash;
if (source && source[0]) {
anchorHash = document.location.hash.substring(1);
lines = source[0].getElementsByTagName('li');
totalLines = lines.length;
for (; i < totalLines; i++) {
lineNumber++;
lineId = 'line' + lineNumber;
lines[i].id = lineId;
if (lineId === anchorHash) {
lines[i].className += ' selected';
}
}
}
})();
================================================
FILE: docs/jsdoc/scripts/prettify/Apache-License-2.0.txt
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed 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.
================================================
FILE: docs/jsdoc/scripts/prettify/lang-css.js
================================================
PR.registerLangHandler(PR.createSimpleLexer([["pln",/^[\t\n\f\r ]+/,null," \t\r\n "]],[["str",/^"(?:[^\n\f\r"\\]|\\(?:\r\n?|\n|\f)|\\[\S\s])*"/,null],["str",/^'(?:[^\n\f\r'\\]|\\(?:\r\n?|\n|\f)|\\[\S\s])*'/,null],["lang-css-str",/^url\(([^"')]*)\)/i],["kwd",/^(?:url|rgb|!important|@import|@page|@media|@charset|inherit)(?=[^\w-]|$)/i,null],["lang-css-kw",/^(-?(?:[_a-z]|\\[\da-f]+ ?)(?:[\w-]|\\\\[\da-f]+ ?)*)\s*:/i],["com",/^\/\*[^*]*\*+(?:[^*/][^*]*\*+)*\//],["com",
/^(?:<\!--|--\>)/],["lit",/^(?:\d+|\d*\.\d+)(?:%|[a-z]+)?/i],["lit",/^#[\da-f]{3,6}/i],["pln",/^-?(?:[_a-z]|\\[\da-f]+ ?)(?:[\w-]|\\\\[\da-f]+ ?)*/i],["pun",/^[^\s\w"']+/]]),["css"]);PR.registerLangHandler(PR.createSimpleLexer([],[["kwd",/^-?(?:[_a-z]|\\[\da-f]+ ?)(?:[\w-]|\\\\[\da-f]+ ?)*/i]]),["css-kw"]);PR.registerLangHandler(PR.createSimpleLexer([],[["str",/^[^"')]+/]]),["css-str"]);
================================================
FILE: docs/jsdoc/scripts/prettify/prettify.js
================================================
var q=null;window.PR_SHOULD_USE_CONTINUATION=!0;
(function(){function L(a){function m(a){var f=a.charCodeAt(0);if(f!==92)return f;var b=a.charAt(1);return(f=r[b])?f:"0"<=b&&b<="7"?parseInt(a.substring(1),8):b==="u"||b==="x"?parseInt(a.substring(2),16):a.charCodeAt(1)}function e(a){if(a<32)return(a<16?"\\x0":"\\x")+a.toString(16);a=String.fromCharCode(a);if(a==="\\"||a==="-"||a==="["||a==="]")a="\\"+a;return a}function h(a){for(var f=a.substring(1,a.length-1).match(/\\u[\dA-Fa-f]{4}|\\x[\dA-Fa-f]{2}|\\[0-3][0-7]{0,2}|\\[0-7]{1,2}|\\[\S\s]|[^\\]/g),a=
[],b=[],o=f[0]==="^",c=o?1:0,i=f.length;c122||(d<65||j>90||b.push([Math.max(65,j)|32,Math.min(d,90)|32]),d<97||j>122||b.push([Math.max(97,j)&-33,Math.min(d,122)&-33]))}}b.sort(function(a,f){return a[0]-f[0]||f[1]-a[1]});f=[];j=[NaN,NaN];for(c=0;ci[0]&&(i[1]+1>i[0]&&b.push("-"),b.push(e(i[1])));b.push("]");return b.join("")}function y(a){for(var f=a.source.match(/\[(?:[^\\\]]|\\[\S\s])*]|\\u[\dA-Fa-f]{4}|\\x[\dA-Fa-f]{2}|\\\d+|\\[^\dux]|\(\?[!:=]|[()^]|[^()[\\^]+/g),b=f.length,d=[],c=0,i=0;c=2&&a==="["?f[c]=h(j):a!=="\\"&&(f[c]=j.replace(/[A-Za-z]/g,function(a){a=a.charCodeAt(0);return"["+String.fromCharCode(a&-33,a|32)+"]"}));return f.join("")}for(var t=0,s=!1,l=!1,p=0,d=a.length;p=5&&"lang-"===b.substring(0,5))&&!(o&&typeof o[1]==="string"))c=!1,b="src";c||(r[f]=b)}i=d;d+=f.length;if(c){c=o[1];var j=f.indexOf(c),k=j+c.length;o[2]&&(k=f.length-o[2].length,j=k-c.length);b=b.substring(5);B(l+i,f.substring(0,j),e,p);B(l+i+j,c,C(b,c),p);B(l+i+k,f.substring(k),e,p)}else p.push(l+i,b)}a.e=p}var h={},y;(function(){for(var e=a.concat(m),
l=[],p={},d=0,g=e.length;d=0;)h[n.charAt(k)]=r;r=r[1];n=""+r;p.hasOwnProperty(n)||(l.push(r),p[n]=q)}l.push(/[\S\s]/);y=L(l)})();var t=m.length;return e}function u(a){var m=[],e=[];a.tripleQuotedStrings?m.push(["str",/^(?:'''(?:[^'\\]|\\[\S\s]|''?(?=[^']))*(?:'''|$)|"""(?:[^"\\]|\\[\S\s]|""?(?=[^"]))*(?:"""|$)|'(?:[^'\\]|\\[\S\s])*(?:'|$)|"(?:[^"\\]|\\[\S\s])*(?:"|$))/,q,"'\""]):a.multiLineStrings?m.push(["str",/^(?:'(?:[^'\\]|\\[\S\s])*(?:'|$)|"(?:[^"\\]|\\[\S\s])*(?:"|$)|`(?:[^\\`]|\\[\S\s])*(?:`|$))/,
q,"'\"`"]):m.push(["str",/^(?:'(?:[^\n\r'\\]|\\.)*(?:'|$)|"(?:[^\n\r"\\]|\\.)*(?:"|$))/,q,"\"'"]);a.verbatimStrings&&e.push(["str",/^@"(?:[^"]|"")*(?:"|$)/,q]);var h=a.hashComments;h&&(a.cStyleComments?(h>1?m.push(["com",/^#(?:##(?:[^#]|#(?!##))*(?:###|$)|.*)/,q,"#"]):m.push(["com",/^#(?:(?:define|elif|else|endif|error|ifdef|include|ifndef|line|pragma|undef|warning)\b|[^\n\r]*)/,q,"#"]),e.push(["str",/^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h|[a-z]\w*)>/,q])):m.push(["com",/^#[^\n\r]*/,
q,"#"]));a.cStyleComments&&(e.push(["com",/^\/\/[^\n\r]*/,q]),e.push(["com",/^\/\*[\S\s]*?(?:\*\/|$)/,q]));a.regexLiterals&&e.push(["lang-regex",/^(?:^^\.?|[!+-]|!=|!==|#|%|%=|&|&&|&&=|&=|\(|\*|\*=|\+=|,|-=|->|\/|\/=|:|::|;|<|<<|<<=|<=|=|==|===|>|>=|>>|>>=|>>>|>>>=|[?@[^]|\^=|\^\^|\^\^=|{|\||\|=|\|\||\|\|=|~|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\s*(\/(?=[^*/])(?:[^/[\\]|\\[\S\s]|\[(?:[^\\\]]|\\[\S\s])*(?:]|$))+\/)/]);(h=a.types)&&e.push(["typ",h]);a=(""+a.keywords).replace(/^ | $/g,
"");a.length&&e.push(["kwd",RegExp("^(?:"+a.replace(/[\s,]+/g,"|")+")\\b"),q]);m.push(["pln",/^\s+/,q," \r\n\t\xa0"]);e.push(["lit",/^@[$_a-z][\w$@]*/i,q],["typ",/^(?:[@_]?[A-Z]+[a-z][\w$@]*|\w+_t\b)/,q],["pln",/^[$_a-z][\w$@]*/i,q],["lit",/^(?:0x[\da-f]+|(?:\d(?:_\d+)*\d*(?:\.\d*)?|\.\d\+)(?:e[+-]?\d+)?)[a-z]*/i,q,"0123456789"],["pln",/^\\[\S\s]?/,q],["pun",/^.[^\s\w"-$'./@\\`]*/,q]);return x(m,e)}function D(a,m){function e(a){switch(a.nodeType){case 1:if(k.test(a.className))break;if("BR"===a.nodeName)h(a),
a.parentNode&&a.parentNode.removeChild(a);else for(a=a.firstChild;a;a=a.nextSibling)e(a);break;case 3:case 4:if(p){var b=a.nodeValue,d=b.match(t);if(d){var c=b.substring(0,d.index);a.nodeValue=c;(b=b.substring(d.index+d[0].length))&&a.parentNode.insertBefore(s.createTextNode(b),a.nextSibling);h(a);c||a.parentNode.removeChild(a)}}}}function h(a){function b(a,d){var e=d?a.cloneNode(!1):a,f=a.parentNode;if(f){var f=b(f,1),g=a.nextSibling;f.appendChild(e);for(var h=g;h;h=g)g=h.nextSibling,f.appendChild(h)}return e}
for(;!a.nextSibling;)if(a=a.parentNode,!a)return;for(var a=b(a.nextSibling,0),e;(e=a.parentNode)&&e.nodeType===1;)a=e;d.push(a)}var k=/(?:^|\s)nocode(?:\s|$)/,t=/\r\n?|\n/,s=a.ownerDocument,l;a.currentStyle?l=a.currentStyle.whiteSpace:window.getComputedStyle&&(l=s.defaultView.getComputedStyle(a,q).getPropertyValue("white-space"));var p=l&&"pre"===l.substring(0,3);for(l=s.createElement("LI");a.firstChild;)l.appendChild(a.firstChild);for(var d=[l],g=0;g=0;){var h=m[e];A.hasOwnProperty(h)?window.console&&console.warn("cannot override language handler %s",h):A[h]=a}}function C(a,m){if(!a||!A.hasOwnProperty(a))a=/^\s*=o&&(h+=2);e>=c&&(a+=2)}}catch(w){"console"in window&&console.log(w&&w.stack?w.stack:w)}}var v=["break,continue,do,else,for,if,return,while"],w=[[v,"auto,case,char,const,default,double,enum,extern,float,goto,int,long,register,short,signed,sizeof,static,struct,switch,typedef,union,unsigned,void,volatile"],
"catch,class,delete,false,import,new,operator,private,protected,public,this,throw,true,try,typeof"],F=[w,"alignof,align_union,asm,axiom,bool,concept,concept_map,const_cast,constexpr,decltype,dynamic_cast,explicit,export,friend,inline,late_check,mutable,namespace,nullptr,reinterpret_cast,static_assert,static_cast,template,typeid,typename,using,virtual,where"],G=[w,"abstract,boolean,byte,extends,final,finally,implements,import,instanceof,null,native,package,strictfp,super,synchronized,throws,transient"],
H=[G,"as,base,by,checked,decimal,delegate,descending,dynamic,event,fixed,foreach,from,group,implicit,in,interface,internal,into,is,lock,object,out,override,orderby,params,partial,readonly,ref,sbyte,sealed,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,var"],w=[w,"debugger,eval,export,function,get,null,set,undefined,var,with,Infinity,NaN"],I=[v,"and,as,assert,class,def,del,elif,except,exec,finally,from,global,import,in,is,lambda,nonlocal,not,or,pass,print,raise,try,with,yield,False,True,None"],
J=[v,"alias,and,begin,case,class,def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,rescue,retry,self,super,then,true,undef,unless,until,when,yield,BEGIN,END"],v=[v,"case,done,elif,esac,eval,fi,function,in,local,set,then,until"],K=/^(DIR|FILE|vector|(de|priority_)?queue|list|stack|(const_)?iterator|(multi)?(set|map)|bitset|u?(int|float)\d*)/,N=/\S/,O=u({keywords:[F,H,w,"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END"+
I,J,v],hashComments:!0,cStyleComments:!0,multiLineStrings:!0,regexLiterals:!0}),A={};k(O,["default-code"]);k(x([],[["pln",/^[^]*(?:>|$)/],["com",/^<\!--[\S\s]*?(?:--\>|$)/],["lang-",/^<\?([\S\s]+?)(?:\?>|$)/],["lang-",/^<%([\S\s]+?)(?:%>|$)/],["pun",/^(?:<[%?]|[%?]>)/],["lang-",/^]*>([\S\s]+?)<\/xmp\b[^>]*>/i],["lang-js",/^]*>([\S\s]*?)(<\/script\b[^>]*>)/i],["lang-css",/^]*>([\S\s]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i]]),
["default-markup","htm","html","mxml","xhtml","xml","xsl"]);k(x([["pln",/^\s+/,q," \t\r\n"],["atv",/^(?:"[^"]*"?|'[^']*'?)/,q,"\"'"]],[["tag",/^^<\/?[a-z](?:[\w-.:]*\w)?|\/?>$/i],["atn",/^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],["lang-uq.val",/^=\s*([^\s"'>]*(?:[^\s"'/>]|\/(?=\s)))/],["pun",/^[/<->]+/],["lang-js",/^on\w+\s*=\s*"([^"]+)"/i],["lang-js",/^on\w+\s*=\s*'([^']+)'/i],["lang-js",/^on\w+\s*=\s*([^\s"'>]+)/i],["lang-css",/^style\s*=\s*"([^"]+)"/i],["lang-css",/^style\s*=\s*'([^']+)'/i],["lang-css",
/^style\s*=\s*([^\s"'>]+)/i]]),["in.tag"]);k(x([],[["atv",/^[\S\s]+/]]),["uq.val"]);k(u({keywords:F,hashComments:!0,cStyleComments:!0,types:K}),["c","cc","cpp","cxx","cyc","m"]);k(u({keywords:"null,true,false"}),["json"]);k(u({keywords:H,hashComments:!0,cStyleComments:!0,verbatimStrings:!0,types:K}),["cs"]);k(u({keywords:G,cStyleComments:!0}),["java"]);k(u({keywords:v,hashComments:!0,multiLineStrings:!0}),["bsh","csh","sh"]);k(u({keywords:I,hashComments:!0,multiLineStrings:!0,tripleQuotedStrings:!0}),
["cv","py"]);k(u({keywords:"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END",hashComments:!0,multiLineStrings:!0,regexLiterals:!0}),["perl","pl","pm"]);k(u({keywords:J,hashComments:!0,multiLineStrings:!0,regexLiterals:!0}),["rb"]);k(u({keywords:w,cStyleComments:!0,regexLiterals:!0}),["js"]);k(u({keywords:"all,and,by,catch,class,else,extends,false,finally,for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,true,try,unless,until,when,while,yes",
hashComments:3,cStyleComments:!0,multilineStrings:!0,tripleQuotedStrings:!0,regexLiterals:!0}),["coffee"]);k(x([],[["str",/^[\S\s]+/]]),["regex"]);window.prettyPrintOne=function(a,m,e){var h=document.createElement("PRE");h.innerHTML=a;e&&D(h,e);E({g:m,i:e,h:h});return h.innerHTML};window.prettyPrint=function(a){function m(){for(var e=window.PR_SHOULD_USE_CONTINUATION?l.now()+250:Infinity;p=0){var k=k.match(g),f,b;if(b=
!k){b=n;for(var o=void 0,c=b.firstChild;c;c=c.nextSibling)var i=c.nodeType,o=i===1?o?b:c:i===3?N.test(c.nodeValue)?b:o:o;b=(f=o===b?void 0:o)&&"CODE"===f.tagName}b&&(k=f.className.match(g));k&&(k=k[1]);b=!1;for(o=n.parentNode;o;o=o.parentNode)if((o.tagName==="pre"||o.tagName==="code"||o.tagName==="xmp")&&o.className&&o.className.indexOf("prettyprint")>=0){b=!0;break}b||((b=(b=n.className.match(/\blinenums\b(?::(\d+))?/))?b[1]&&b[1].length?+b[1]:!0:!1)&&D(n,b),d={g:k,h:n,i:b},E(d))}}p p:first-child,
.props td.description > p:first-child
{
margin-top: 0;
padding-top: 0;
}
.params td.description > p:last-child,
.props td.description > p:last-child
{
margin-bottom: 0;
padding-bottom: 0;
}
.disabled {
color: #454545;
}
================================================
FILE: docs/jsdoc/styles/prettify-jsdoc.css
================================================
/* JSDoc prettify.js theme */
/* plain text */
.pln {
color: #000000;
font-weight: normal;
font-style: normal;
}
/* string content */
.str {
color: #006400;
font-weight: normal;
font-style: normal;
}
/* a keyword */
.kwd {
color: #000000;
font-weight: bold;
font-style: normal;
}
/* a comment */
.com {
font-weight: normal;
font-style: italic;
}
/* a type name */
.typ {
color: #000000;
font-weight: normal;
font-style: normal;
}
/* a literal value */
.lit {
color: #006400;
font-weight: normal;
font-style: normal;
}
/* punctuation */
.pun {
color: #000000;
font-weight: bold;
font-style: normal;
}
/* lisp open bracket */
.opn {
color: #000000;
font-weight: bold;
font-style: normal;
}
/* lisp close bracket */
.clo {
color: #000000;
font-weight: bold;
font-style: normal;
}
/* a markup tag name */
.tag {
color: #006400;
font-weight: normal;
font-style: normal;
}
/* a markup attribute name */
.atn {
color: #006400;
font-weight: normal;
font-style: normal;
}
/* a markup attribute value */
.atv {
color: #006400;
font-weight: normal;
font-style: normal;
}
/* a declaration */
.dec {
color: #000000;
font-weight: bold;
font-style: normal;
}
/* a variable name */
.var {
color: #000000;
font-weight: normal;
font-style: normal;
}
/* a function name */
.fun {
color: #000000;
font-weight: bold;
font-style: normal;
}
/* Specify class=linenums on a pre to get line numbering */
ol.linenums {
margin-top: 0;
margin-bottom: 0;
}
================================================
FILE: docs/jsdoc/styles/prettify-tomorrow.css
================================================
/* Tomorrow Theme */
/* Original theme - https://github.com/chriskempson/tomorrow-theme */
/* Pretty printing styles. Used with prettify.js. */
/* SPAN elements with the classes below are added by prettyprint. */
/* plain text */
.pln {
color: #4d4d4c; }
@media screen {
/* string content */
.str {
color: #718c00; }
/* a keyword */
.kwd {
color: #8959a8; }
/* a comment */
.com {
color: #8e908c; }
/* a type name */
.typ {
color: #4271ae; }
/* a literal value */
.lit {
color: #f5871f; }
/* punctuation */
.pun {
color: #4d4d4c; }
/* lisp open bracket */
.opn {
color: #4d4d4c; }
/* lisp close bracket */
.clo {
color: #4d4d4c; }
/* a markup tag name */
.tag {
color: #c82829; }
/* a markup attribute name */
.atn {
color: #f5871f; }
/* a markup attribute value */
.atv {
color: #3e999f; }
/* a declaration */
.dec {
color: #f5871f; }
/* a variable name */
.var {
color: #c82829; }
/* a function name */
.fun {
color: #4271ae; } }
/* Use higher contrast and text-weight for printable form. */
@media print, projection {
.str {
color: #060; }
.kwd {
color: #006;
font-weight: bold; }
.com {
color: #600;
font-style: italic; }
.typ {
color: #404;
font-weight: bold; }
.lit {
color: #044; }
.pun, .opn, .clo {
color: #440; }
.tag {
color: #006;
font-weight: bold; }
.atn {
color: #404; }
.atv {
color: #060; } }
/* Style */
/*
pre.prettyprint {
background: white;
font-family: Consolas, Monaco, 'Andale Mono', monospace;
font-size: 12px;
line-height: 1.5;
border: 1px solid #ccc;
padding: 10px; }
*/
/* Specify class=linenums on a pre to get line numbering */
ol.linenums {
margin-top: 0;
margin-bottom: 0; }
/* IE indents via margin-left */
li.L0,
li.L1,
li.L2,
li.L3,
li.L4,
li.L5,
li.L6,
li.L7,
li.L8,
li.L9 {
/* */ }
/* Alternate shading for lines */
li.L1,
li.L3,
li.L5,
li.L7,
li.L9 {
/* */ }
================================================
FILE: docs/jsdoc/tuple.js.html
================================================
JSDoc: Source: tuple.js
Source: tuple.js
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/
/** @module reactive-pg-client-js/tuple */
var utils = require('vertx-js/util/utils');
var Json = require('reactive-pg-client-js/json');
var Buffer = require('vertx-js/buffer');
var io = Packages.io;
var JsonObject = io.vertx.core.json.JsonObject;
var JTuple = Java.type('io.reactiverse.pgclient.Tuple');
var Point = Java.type('io.reactiverse.pgclient.data.Point');
var Path = Java.type('io.reactiverse.pgclient.data.Path');
var Box = Java.type('io.reactiverse.pgclient.data.Box');
var Circle = Java.type('io.reactiverse.pgclient.data.Circle');
var Polygon = Java.type('io.reactiverse.pgclient.data.Polygon');
var Interval = Java.type('io.reactiverse.pgclient.data.Interval');
var LineSegment = Java.type('io.reactiverse.pgclient.data.LineSegment');
var Line = Java.type('io.reactiverse.pgclient.data.Line');
/**
A general purpose tuple.
@class
*/
var Tuple = function(j_val) {
var j_tuple = j_val;
var that = this;
var __super_tuple = this.tuple;
var __super_of = this.of;
var __super_of = this.of;
var __super_of = this.of;
var __super_of = this.of;
var __super_of = this.of;
var __super_of = this.of;
var __super_getBoolean = this.getBoolean;
var __super_getValue = this.getValue;
var __super_getShort = this.getShort;
var __super_getInteger = this.getInteger;
var __super_getLong = this.getLong;
var __super_getFloat = this.getFloat;
var __super_getDouble = this.getDouble;
var __super_getString = this.getString;
var __super_getJson = this.getJson;
var __super_getPoint = this.getPoint;
var __super_getLine = this.getLine;
var __super_getLineSegment = this.getLineSegment;
var __super_getBox = this.getBox;
var __super_getPath = this.getPath;
var __super_getPolygon = this.getPolygon;
var __super_getCircle = this.getCircle;
var __super_getInterval = this.getInterval;
var __super_getBuffer = this.getBuffer;
var __super_addBoolean = this.addBoolean;
var __super_addValue = this.addValue;
var __super_addShort = this.addShort;
var __super_addInteger = this.addInteger;
var __super_addLong = this.addLong;
var __super_addFloat = this.addFloat;
var __super_addDouble = this.addDouble;
var __super_addString = this.addString;
var __super_addJson = this.addJson;
var __super_addBuffer = this.addBuffer;
var __super_addPoint = this.addPoint;
var __super_addLine = this.addLine;
var __super_addLineSegment = this.addLineSegment;
var __super_addBox = this.addBox;
var __super_addPath = this.addPath;
var __super_addPolygon = this.addPolygon;
var __super_addCircle = this.addCircle;
var __super_addInterval = this.addInterval;
var __super_size = this.size;
var __super_clear = this.clear;
/**
Get a boolean value at <code>pos</code>.
@public
@param pos {number} the position
@return {boolean} the value or <code>null</code>
*/
this.getBoolean = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return j_tuple["getBoolean(int)"](__args[0]) ;
} else if (typeof __super_getBoolean != 'undefined') {
return __super_getBoolean.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get an object value at <code>pos</code>.
@public
@param pos {number} the position
@return {Object} the value or <code>null</code>
*/
this.getValue = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnTypeUnknown(j_tuple["getValue(int)"](__args[0])) ;
} else if (typeof __super_getValue != 'undefined') {
return __super_getValue.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a short value at <code>pos</code>.
@public
@param pos {number} the position
@return {number} the value or <code>null</code>
*/
this.getShort = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return j_tuple["getShort(int)"](__args[0]) ;
} else if (typeof __super_getShort != 'undefined') {
return __super_getShort.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get an integer value at <code>pos</code>.
@public
@param pos {number} the position
@return {number} the value or <code>null</code>
*/
this.getInteger = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return j_tuple["getInteger(int)"](__args[0]) ;
} else if (typeof __super_getInteger != 'undefined') {
return __super_getInteger.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a long value at <code>pos</code>.
@public
@param pos {number} the position
@return {number} the value or <code>null</code>
*/
this.getLong = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnLong(j_tuple["getLong(int)"](__args[0])) ;
} else if (typeof __super_getLong != 'undefined') {
return __super_getLong.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a float value at <code>pos</code>.
@public
@param pos {number} the position
@return {number} the value or <code>null</code>
*/
this.getFloat = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return j_tuple["getFloat(int)"](__args[0]) ;
} else if (typeof __super_getFloat != 'undefined') {
return __super_getFloat.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a double value at <code>pos</code>.
@public
@param pos {number} the position
@return {number} the value or <code>null</code>
*/
this.getDouble = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return j_tuple["getDouble(int)"](__args[0]) ;
} else if (typeof __super_getDouble != 'undefined') {
return __super_getDouble.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a string value at <code>pos</code>.
@public
@param pos {number} the position
@return {string} the value or <code>null</code>
*/
this.getString = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return j_tuple["getString(int)"](__args[0]) ;
} else if (typeof __super_getString != 'undefined') {
return __super_getString.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a json value at <code>pos</code>.
@public
@param pos {number} the position
@return {Json} the value or <code>null</code>
*/
this.getJson = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnVertxGen(Json, j_tuple["getJson(int)"](__args[0])) ;
} else if (typeof __super_getJson != 'undefined') {
return __super_getJson.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param pos {number} the position
@return {Object} the value or <code>null</code>
*/
this.getPoint = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnDataObject(j_tuple["getPoint(int)"](__args[0])) ;
} else if (typeof __super_getPoint != 'undefined') {
return __super_getPoint.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param pos {number} the position
@return {Object} the value or <code>null</code>
*/
this.getLine = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnDataObject(j_tuple["getLine(int)"](__args[0])) ;
} else if (typeof __super_getLine != 'undefined') {
return __super_getLine.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param pos {number} the position
@return {Object} the value or <code>null</code>
*/
this.getLineSegment = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnDataObject(j_tuple["getLineSegment(int)"](__args[0])) ;
} else if (typeof __super_getLineSegment != 'undefined') {
return __super_getLineSegment.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param pos {number} the position
@return {Object} the value or <code>null</code>
*/
this.getBox = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnDataObject(j_tuple["getBox(int)"](__args[0])) ;
} else if (typeof __super_getBox != 'undefined') {
return __super_getBox.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param pos {number} the position
@return {Object} the value or <code>null</code>
*/
this.getPath = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnDataObject(j_tuple["getPath(int)"](__args[0])) ;
} else if (typeof __super_getPath != 'undefined') {
return __super_getPath.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param pos {number} the position
@return {Object} the value or <code>null</code>
*/
this.getPolygon = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnDataObject(j_tuple["getPolygon(int)"](__args[0])) ;
} else if (typeof __super_getPolygon != 'undefined') {
return __super_getPolygon.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param pos {number} the position
@return {Object} the value or <code>null</code>
*/
this.getCircle = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnDataObject(j_tuple["getCircle(int)"](__args[0])) ;
} else if (typeof __super_getCircle != 'undefined') {
return __super_getCircle.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get value at <code>pos</code>.
@public
@param pos {number} the position
@return {Object} the value or <code>null</code>
*/
this.getInterval = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnDataObject(j_tuple["getInterval(int)"](__args[0])) ;
} else if (typeof __super_getInterval != 'undefined') {
return __super_getInterval.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Get a buffer value at <code>pos</code>.
@public
@param pos {number} the position
@return {Buffer} the value or <code>null</code>
*/
this.getBuffer = function(pos) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
return utils.convReturnVertxGen(Buffer, j_tuple["getBuffer(int)"](__args[0])) ;
} else if (typeof __super_getBuffer != 'undefined') {
return __super_getBuffer.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a boolean value at the end of the tuple.
@public
@param value {boolean} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addBoolean = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='boolean') {
j_tuple["addBoolean(java.lang.Boolean)"](__args[0]) ;
return that;
} else if (typeof __super_addBoolean != 'undefined') {
return __super_addBoolean.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add an object value at the end of the tuple.
@public
@param value {Object} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addValue = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] !== 'function') {
j_tuple["addValue(java.lang.Object)"](utils.convParamTypeUnknown(__args[0])) ;
return that;
} else if (typeof __super_addValue != 'undefined') {
return __super_addValue.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a short value at the end of the tuple.
@public
@param value {number} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addShort = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
j_tuple["addShort(java.lang.Short)"](utils.convParamShort(__args[0])) ;
return that;
} else if (typeof __super_addShort != 'undefined') {
return __super_addShort.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add an integer value at the end of the tuple.
@public
@param value {number} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addInteger = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
j_tuple["addInteger(java.lang.Integer)"](utils.convParamInteger(__args[0])) ;
return that;
} else if (typeof __super_addInteger != 'undefined') {
return __super_addInteger.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a long value at the end of the tuple.
@public
@param value {number} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addLong = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
j_tuple["addLong(java.lang.Long)"](utils.convParamLong(__args[0])) ;
return that;
} else if (typeof __super_addLong != 'undefined') {
return __super_addLong.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a float value at the end of the tuple.
@public
@param value {number} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addFloat = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
j_tuple["addFloat(java.lang.Float)"](utils.convParamFloat(__args[0])) ;
return that;
} else if (typeof __super_addFloat != 'undefined') {
return __super_addFloat.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a double value at the end of the tuple.
@public
@param value {number} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addDouble = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] ==='number') {
j_tuple["addDouble(java.lang.Double)"](utils.convParamDouble(__args[0])) ;
return that;
} else if (typeof __super_addDouble != 'undefined') {
return __super_addDouble.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a string value at the end of the tuple.
@public
@param value {string} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addString = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'string') {
j_tuple["addString(java.lang.String)"](__args[0]) ;
return that;
} else if (typeof __super_addString != 'undefined') {
return __super_addString.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a json value at the end of the tuple.
@public
@param value {Json} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addJson = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'object' && __args[0]._jdel) {
j_tuple["addJson(io.reactiverse.pgclient.data.Json)"](__args[0]._jdel) ;
return that;
} else if (typeof __super_addJson != 'undefined') {
return __super_addJson.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a buffer value at the end of the tuple.
@public
@param value {Buffer} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addBuffer = function(value) {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] === 'object' && __args[0]._jdel) {
j_tuple["addBuffer(io.vertx.core.buffer.Buffer)"](__args[0]._jdel) ;
return that;
} else if (typeof __super_addBuffer != 'undefined') {
return __super_addBuffer.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a value at the end of the tuple.
@public
@param value {Object} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addPoint = function(value) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'object' && __args[0] != null)) {
j_tuple["addPoint(io.reactiverse.pgclient.data.Point)"](__args[0] != null ? new Point(new JsonObject(Java.asJSONCompatible(__args[0]))) : null) ;
return that;
} else if (typeof __super_addPoint != 'undefined') {
return __super_addPoint.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a value at the end of the tuple.
@public
@param value {Object} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addLine = function(value) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'object' && __args[0] != null)) {
j_tuple["addLine(io.reactiverse.pgclient.data.Line)"](__args[0] != null ? new Line(new JsonObject(Java.asJSONCompatible(__args[0]))) : null) ;
return that;
} else if (typeof __super_addLine != 'undefined') {
return __super_addLine.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a value at the end of the tuple.
@public
@param value {Object} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addLineSegment = function(value) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'object' && __args[0] != null)) {
j_tuple["addLineSegment(io.reactiverse.pgclient.data.LineSegment)"](__args[0] != null ? new LineSegment(new JsonObject(Java.asJSONCompatible(__args[0]))) : null) ;
return that;
} else if (typeof __super_addLineSegment != 'undefined') {
return __super_addLineSegment.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a value at the end of the tuple.
@public
@param value {Object} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addBox = function(value) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'object' && __args[0] != null)) {
j_tuple["addBox(io.reactiverse.pgclient.data.Box)"](__args[0] != null ? new Box(new JsonObject(Java.asJSONCompatible(__args[0]))) : null) ;
return that;
} else if (typeof __super_addBox != 'undefined') {
return __super_addBox.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a value at the end of the tuple.
@public
@param value {Object} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addPath = function(value) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'object' && __args[0] != null)) {
j_tuple["addPath(io.reactiverse.pgclient.data.Path)"](__args[0] != null ? new Path(new JsonObject(Java.asJSONCompatible(__args[0]))) : null) ;
return that;
} else if (typeof __super_addPath != 'undefined') {
return __super_addPath.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a value at the end of the tuple.
@public
@param value {Object} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addPolygon = function(value) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'object' && __args[0] != null)) {
j_tuple["addPolygon(io.reactiverse.pgclient.data.Polygon)"](__args[0] != null ? new Polygon(new JsonObject(Java.asJSONCompatible(__args[0]))) : null) ;
return that;
} else if (typeof __super_addPolygon != 'undefined') {
return __super_addPolygon.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a value at the end of the tuple.
@public
@param value {Object} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addCircle = function(value) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'object' && __args[0] != null)) {
j_tuple["addCircle(io.reactiverse.pgclient.data.Circle)"](__args[0] != null ? new Circle(new JsonObject(Java.asJSONCompatible(__args[0]))) : null) ;
return that;
} else if (typeof __super_addCircle != 'undefined') {
return __super_addCircle.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
Add a value at the end of the tuple.
@public
@param value {Object} the value
@return {Tuple} a reference to this, so the API can be used fluently
*/
this.addInterval = function(value) {
var __args = arguments;
if (__args.length === 1 && (typeof __args[0] === 'object' && __args[0] != null)) {
j_tuple["addInterval(io.reactiverse.pgclient.data.Interval)"](__args[0] != null ? new Interval(new JsonObject(Java.asJSONCompatible(__args[0]))) : null) ;
return that;
} else if (typeof __super_addInterval != 'undefined') {
return __super_addInterval.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
@return {number} the tuple size
*/
this.size = function() {
var __args = arguments;
if (__args.length === 0) {
return j_tuple["size()"]() ;
} else if (typeof __super_size != 'undefined') {
return __super_size.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
/**
@public
*/
this.clear = function() {
var __args = arguments;
if (__args.length === 0) {
j_tuple["clear()"]();
} else if (typeof __super_clear != 'undefined') {
return __super_clear.apply(this, __args);
}
else throw new TypeError('function invoked with invalid arguments');
};
// A reference to the underlying Java delegate
// NOTE! This is an internal API and must not be used in user code.
// If you rely on this property your code is likely to break if we change it / remove it without warning.
this._jdel = j_tuple;
};
Tuple._jclass = utils.getJavaClass("io.reactiverse.pgclient.Tuple");
Tuple._jtype = {accept: function(obj) {
return Tuple._jclass.isInstance(obj._jdel);
},wrap: function(jdel) {
var obj = Object.create(Tuple.prototype, {});
Tuple.apply(obj, arguments);
return obj;
},
unwrap: function(obj) {
return obj._jdel;
}
};
Tuple._create = function(jdel) {var obj = Object.create(Tuple.prototype, {});
Tuple.apply(obj, arguments);
return obj;
}
/**
@memberof module:reactive-pg-client-js/tuple
@return {Tuple} a new empty tuple
*/
Tuple.tuple = function() {
var __args = arguments;
if (__args.length === 0) {
return utils.convReturnVertxGen(Tuple, JTuple["tuple()"]()) ;
}else throw new TypeError('function invoked with invalid arguments');
};
/**
Create a tuple of six elements.
@memberof module:reactive-pg-client-js/tuple
@param elt1 {Object} the first value
@param elt2 {Object} the second valueg
@param elt3 {Object} the third value
@param elt4 {Object} the fourth value
@param elt5 {Object} the fifth value
@param elt6 {Object} the sixth value
@return {Tuple} the tuple
*/
Tuple.of = function() {
var __args = arguments;
if (__args.length === 1 && typeof __args[0] !== 'function') {
return utils.convReturnVertxGen(Tuple, JTuple["of(java.lang.Object)"](utils.convParamTypeUnknown(__args[0]))) ;
} else if (__args.length === 2 && typeof __args[0] !== 'function' && typeof __args[1] !== 'function') {
return utils.convReturnVertxGen(Tuple, JTuple["of(java.lang.Object,java.lang.Object)"](utils.convParamTypeUnknown(__args[0]), utils.convParamTypeUnknown(__args[1]))) ;
} else if (__args.length === 3 && typeof __args[0] !== 'function' && typeof __args[1] !== 'function' && typeof __args[2] !== 'function') {
return utils.convReturnVertxGen(Tuple, JTuple["of(java.lang.Object,java.lang.Object,java.lang.Object)"](utils.convParamTypeUnknown(__args[0]), utils.convParamTypeUnknown(__args[1]), utils.convParamTypeUnknown(__args[2]))) ;
} else if (__args.length === 4 && typeof __args[0] !== 'function' && typeof __args[1] !== 'function' && typeof __args[2] !== 'function' && typeof __args[3] !== 'function') {
return utils.convReturnVertxGen(Tuple, JTuple["of(java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object)"](utils.convParamTypeUnknown(__args[0]), utils.convParamTypeUnknown(__args[1]), utils.convParamTypeUnknown(__args[2]), utils.convParamTypeUnknown(__args[3]))) ;
} else if (__args.length === 5 && typeof __args[0] !== 'function' && typeof __args[1] !== 'function' && typeof __args[2] !== 'function' && typeof __args[3] !== 'function' && typeof __args[4] !== 'function') {
return utils.convReturnVertxGen(Tuple, JTuple["of(java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object)"](utils.convParamTypeUnknown(__args[0]), utils.convParamTypeUnknown(__args[1]), utils.convParamTypeUnknown(__args[2]), utils.convParamTypeUnknown(__args[3]), utils.convParamTypeUnknown(__args[4]))) ;
} else if (__args.length === 6 && typeof __args[0] !== 'function' && typeof __args[1] !== 'function' && typeof __args[2] !== 'function' && typeof __args[3] !== 'function' && typeof __args[4] !== 'function' && typeof __args[5] !== 'function') {
return utils.convReturnVertxGen(Tuple, JTuple["of(java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object)"](utils.convParamTypeUnknown(__args[0]), utils.convParamTypeUnknown(__args[1]), utils.convParamTypeUnknown(__args[2]), utils.convParamTypeUnknown(__args[3]), utils.convParamTypeUnknown(__args[4]), utils.convParamTypeUnknown(__args[5]))) ;
}else throw new TypeError('function invoked with invalid arguments');
};
module.exports = Tuple;
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/json.rb', line 33defself.create(value=nil)if::Vertx::Util::unknown_type.accept?(value)&&!block_given?return::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclientData::Json.java_method(:create,[Java::java.lang.Object.java_class]).call(::Vertx::Util::Utils.to_object(value)),::ReactivePgClient::Json)endraiseArgumentError,"Invalid arguments when calling create(#{value})"end
+ (Object) j_api_type
25
26
27
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/json.rb', line 25defself.j_api_type@@j_api_typeend
+ (Object) j_class
28
29
30
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/json.rb', line 28defself.j_classJava::IoReactiversePgclientData::Json.java_classend
+ (Object) unwrap(obj)
22
23
24
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/json.rb', line 22def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
19
20
21
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/json.rb', line 19def@@j_api_type.wrap(obj)Json.new(obj)end
Instance Method Details
- (Object) value
Returns:
(Object)
Raises:
(ArgumentError)
40
41
42
43
44
45
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/json.rb', line 40defvalueif!block_given?return::Vertx::Util::Utils.from_object(@j_del.java_method(:value,[]).call())endraiseArgumentError,"Invalid arguments when calling value()"end
A channel to Postgres that tracks the subscription to a given Postgres channel using the LISTEN/UNLISTEN commands.
When paused the channel discards the messages.
Set an handler called when the the channel get subscribed.
Class Method Details
+ (Boolean) accept?(obj)
Returns:
(Boolean)
21
22
23
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 21def@@j_api_type.accept?(obj)obj.class==PgChannelend
+ (Object) j_api_type
30
31
32
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 30defself.j_api_type@@j_api_typeend
+ (Object) j_class
33
34
35
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 33defself.j_classJava::IoReactiversePgclientPubsub::PgChannel.java_classend
+ (Object) unwrap(obj)
27
28
29
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 27def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
24
25
26
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 24def@@j_api_type.wrap(obj)PgChannel.new(obj)end
Instance Method Details
- (self) end_handler { ... }
Set an handler to be called when no more notifications will be received.
Yields:
the handler
Returns:
(self)
Raises:
(ArgumentError)
91
92
93
94
95
96
97
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 91defend_handlerifblock_given?@j_del.java_method(:endHandler,[Java::IoVertxCore::Handler.java_class]).call(Proc.new{yield})returnselfendraiseArgumentError,"Invalid arguments when calling end_handler()"end
- (self) exception_handler { ... }
Yields:
Returns:
(self)
Raises:
(ArgumentError)
100
101
102
103
104
105
106
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 100defexception_handlerifblock_given?@j_del.java_method(:exceptionHandler,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|event|yield(::Vertx::Util::Utils.from_throwable(event))}))returnselfendraiseArgumentError,"Invalid arguments when calling exception_handler()"end
- (self) fetch(arg0 = nil)
Parameters:
arg0(Fixnum)(defaults to: nil)
Returns:
(self)
Raises:
(ArgumentError)
38
39
40
41
42
43
44
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 38deffetch(arg0=nil)ifarg0.class==Fixnum&&!block_given?@j_del.java_method(:fetch,[Java::long.java_class]).call(arg0)returnselfendraiseArgumentError,"Invalid arguments when calling fetch(#{arg0})"end
- (self) handler { ... }
Set or unset an handler to be called when a the channel is notified by Postgres.
when the handler is set, the subscriber sends a LISTEN command if needed
when the handler is unset, the subscriber sends a UNLISTEN command if needed
Yields:
the handler
Returns:
(self)
Raises:
(ArgumentError)
63
64
65
66
67
68
69
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 63defhandlerifblock_given?@j_del.java_method(:handler,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|event|yield(event)}))returnselfendraiseArgumentError,"Invalid arguments when calling handler()"end
- (self) pause
Pause the channel, all notifications are discarded.
Returns:
(self)
Raises:
(ArgumentError)
72
73
74
75
76
77
78
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 72defpauseif!block_given?@j_del.java_method(:pause,[]).call()returnselfendraiseArgumentError,"Invalid arguments when calling pause()"end
- (self) resume
Resume the channel.
Returns:
(self)
Raises:
(ArgumentError)
81
82
83
84
85
86
87
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 81defresumeif!block_given?@j_del.java_method(:resume,[]).call()returnselfendraiseArgumentError,"Invalid arguments when calling resume()"end
- (self) subscribe_handler { ... }
Set an handler called when the the channel get subscribed.
Yields:
the handler
Returns:
(self)
Raises:
(ArgumentError)
48
49
50
51
52
53
54
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_channel.rb', line 48defsubscribe_handlerifblock_given?@j_del.java_method(:subscribeHandler,[Java::IoVertxCore::Handler.java_class]).call(Proc.new{yield})returnselfendraiseArgumentError,"Invalid arguments when calling subscribe_handler()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 22def@@j_api_type.accept?(obj)obj.class==PgClientend
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 81defself.connect(param_1=nil,param_2=nil)ifparam_1.class.method_defined?(:j_del)&&block_given?&¶m_2==nilreturnJava::IoReactiversePgclient::PgClient.java_method(:connect,[Java::IoVertxCore::Vertx.java_class,Java::IoVertxCore::Handler.java_class]).call(param_1.j_del,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgConnection):nil)}))elsifparam_1.class.method_defined?(:j_del)&¶m_2.class==Hash&&block_given?returnJava::IoReactiversePgclient::PgClient.java_method(:connect,[Java::IoVertxCore::Vertx.java_class,Java::IoReactiversePgclient::PgConnectOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(param_1.j_del,Java::IoReactiversePgclient::PgConnectOptions.new(::Vertx::Util::Utils.to_json_object(param_2)),(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgConnection):nil)}))elsifparam_1.class.method_defined?(:j_del)&¶m_2.class==String&&block_given?returnJava::IoReactiversePgclient::PgClient.java_method(:connect,[Java::IoVertxCore::Vertx.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(param_1.j_del,param_2,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgConnection):nil)}))endraiseArgumentError,"Invalid arguments when calling connect(#{param_1},#{param_2})"end
+ (Object) j_api_type
31
32
33
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 31defself.j_api_type@@j_api_typeend
+ (Object) j_class
34
35
36
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 34defself.j_classJava::IoReactiversePgclient::PgClient.java_classend
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 52defself.pool(param_1=nil,param_2=nil)if!block_given?&¶m_1==nil&¶m_2==nilreturn::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::PgClient.java_method(:pool,[]).call(),::ReactivePgClient::PgPool)elsifparam_1.class==String&&!block_given?&¶m_2==nilreturn::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::PgClient.java_method(:pool,[Java::java.lang.String.java_class]).call(param_1),::ReactivePgClient::PgPool)elsifparam_1.class.method_defined?(:j_del)&&!block_given?&¶m_2==nilreturn::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::PgClient.java_method(:pool,[Java::IoVertxCore::Vertx.java_class]).call(param_1.j_del),::ReactivePgClient::PgPool)elsifparam_1.class==Hash&&!block_given?&¶m_2==nilreturn::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::PgClient.java_method(:pool,[Java::IoReactiversePgclient::PgPoolOptions.java_class]).call(Java::IoReactiversePgclient::PgPoolOptions.new(::Vertx::Util::Utils.to_json_object(param_1))),::ReactivePgClient::PgPool)elsifparam_1.class.method_defined?(:j_del)&¶m_2.class==String&&!block_given?return::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::PgClient.java_method(:pool,[Java::IoVertxCore::Vertx.java_class,Java::java.lang.String.java_class]).call(param_1.j_del,param_2),::ReactivePgClient::PgPool)elsifparam_1.class.method_defined?(:j_del)&¶m_2.class==Hash&&!block_given?return::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::PgClient.java_method(:pool,[Java::IoVertxCore::Vertx.java_class,Java::IoReactiversePgclient::PgPoolOptions.java_class]).call(param_1.j_del,Java::IoReactiversePgclient::PgPoolOptions.new(::Vertx::Util::Utils.to_json_object(param_2))),::ReactivePgClient::PgPool)endraiseArgumentError,"Invalid arguments when calling pool(#{param_1},#{param_2})"end
+ (Object) unwrap(obj)
28
29
30
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 28def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
25
26
27
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 25def@@j_api_type.wrap(obj)PgClient.new(obj)end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 122defprepared_batch(sql=nil,batch=nil)ifsql.class==String&&batch.class==Array&&block_given?@j_del.java_method(:preparedBatch,[Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,batch.map{|element|element.j_del},(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepared_batch(#{sql},#{batch})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 107defprepared_query(sql=nil,arguments=nil)ifsql.class==String&&block_given?&&arguments==nil@j_del.java_method(:preparedQuery,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfelsifsql.class==String&&arguments.class.method_defined?(:j_del)&&block_given?@j_del.java_method(:preparedQuery,[Java::java.lang.String.java_class,Java::IoReactiversePgclient::Tuple.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,arguments.j_del,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepared_query(#{sql},#{arguments})"end
- (self) query(sql = nil) { ... }
Execute a simple query.
Parameters:
sql(String)(defaults to: nil)
—
the query SQL
Yields:
the handler notified with the execution result
Returns:
(self)
Raises:
(ArgumentError)
95
96
97
98
99
100
101
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_client.rb', line 95defquery(sql=nil)ifsql.class==String&&block_given?@j_del.java_method(:query,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling query(#{sql})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 23def@@j_api_type.accept?(obj)obj.class==PgConnectionend
+ (Object) j_api_type
32
33
34
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 32defself.j_api_type@@j_api_typeend
+ (Object) j_class
35
36
37
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 35defself.j_classJava::IoReactiversePgclient::PgConnection.java_classend
+ (Object) unwrap(obj)
29
30
31
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 29def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
26
27
28
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 26def@@j_api_type.wrap(obj)PgConnection.new(obj)end
Begin a transaction and returns a ReactivePgClient::PgTransaction for controlling and tracking
this transaction.
When the connection is explicitely closed, any inflight transaction is rollbacked.
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 74defbeginif!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:begin,[]).call(),::ReactivePgClient::PgTransaction)endraiseArgumentError,"Invalid arguments when calling begin()"end
Send a request cancellation message to tell the server to cancel processing request in this connection.
Note: Use this with caution because the cancellation signal may or may not have any effect.
Yields:
the handler notified if cancelling request is sent
a reference to this, so the API can be used fluently
Raises:
(ArgumentError)
111
112
113
114
115
116
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 111defcancel_requestifblock_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:cancelRequest,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil)})),::ReactivePgClient::PgConnection)endraiseArgumentError,"Invalid arguments when calling cancel_request()"end
- (void) close
This method returns an undefined value.
Close the current connection after all the pending commands have been processed.
Raises:
(ArgumentError)
126
127
128
129
130
131
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 126defcloseif!block_given?return@j_del.java_method(:close,[]).call()endraiseArgumentError,"Invalid arguments when calling close()"end
- (self) close_handler { ... }
Set an handler called when the connection is closed.
Yields:
the handler
Returns:
(self)
Raises:
(ArgumentError)
62
63
64
65
66
67
68
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 62defclose_handlerifblock_given?@j_del.java_method(:closeHandler,[Java::IoVertxCore::Handler.java_class]).call(Proc.new{yield})returnselfendraiseArgumentError,"Invalid arguments when calling close_handler()"end
- (self) exception_handler { ... }
Set an handler called with connection errors.
Yields:
the handler
Returns:
(self)
Raises:
(ArgumentError)
52
53
54
55
56
57
58
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 52defexception_handlerifblock_given?@j_del.java_method(:exceptionHandler,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|event|yield(::Vertx::Util::Utils.from_throwable(event))}))returnselfendraiseArgumentError,"Invalid arguments when calling exception_handler()"end
- (self) notification_handler { ... }
Set an handler called when the connection receives notification on a channel.
The handler is called with the Hash and has access to the channel name
and the notification payload.
Yields:
the handler
Returns:
(self)
Raises:
(ArgumentError)
86
87
88
89
90
91
92
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 86defnotification_handlerifblock_given?@j_del.java_method(:notificationHandler,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|event|yield(event!=nil?JSON.parse(event.toJson.encode):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling notification_handler()"end
- (self) prepare(sql = nil) { ... }
Create a prepared query.
Parameters:
sql(String)(defaults to: nil)
—
the sql
Yields:
the handler notified with the prepared query asynchronously
Returns:
(self)
Raises:
(ArgumentError)
42
43
44
45
46
47
48
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 42defprepare(sql=nil)ifsql.class==String&&block_given?@j_del.java_method(:prepare,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgPreparedQuery):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepare(#{sql})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 160defprepared_batch(sql=nil,batch=nil)ifsql.class==String&&batch.class==Array&&block_given?@j_del.java_method(:preparedBatch,[Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,batch.map{|element|element.j_del},(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepared_batch(#{sql},#{batch})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 136defprepared_query(sql=nil,arguments=nil)ifsql.class==String&&block_given?&&arguments==nil@j_del.java_method(:preparedQuery,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfelsifsql.class==String&&arguments.class.method_defined?(:j_del)&&block_given?@j_del.java_method(:preparedQuery,[Java::java.lang.String.java_class,Java::IoReactiversePgclient::Tuple.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,arguments.j_del,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepared_query(#{sql},#{arguments})"end
- (Fixnum) process_id
Returns The process ID of the target backend
Returns:
(Fixnum)
—
The process ID of the target backend
Raises:
(ArgumentError)
94
95
96
97
98
99
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 94defprocess_idif!block_given?return@j_del.java_method(:processId,[]).call()endraiseArgumentError,"Invalid arguments when calling process_id()"end
- (self) query(sql = nil) { ... }
Parameters:
sql(String)(defaults to: nil)
Yields:
Returns:
(self)
Raises:
(ArgumentError)
149
150
151
152
153
154
155
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 149defquery(sql=nil)ifsql.class==String&&block_given?@j_del.java_method(:query,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling query(#{sql})"end
- (Fixnum) secret_key
Returns The secret key for the target backend
Returns:
(Fixnum)
—
The secret key for the target backend
Raises:
(ArgumentError)
101
102
103
104
105
106
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 101defsecret_keyif!block_given?return@j_del.java_method(:secretKey,[]).call()endraiseArgumentError,"Invalid arguments when calling secret_key()"end
- (true, false) ssl?
Returns whether the connection uses SSL
Returns:
(true, false)
—
whether the connection uses SSL
Raises:
(ArgumentError)
118
119
120
121
122
123
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_connection.rb', line 118defssl?if!block_given?return@j_del.java_method(:isSSL,[]).call()endraiseArgumentError,"Invalid arguments when calling ssl?()"end
Read rows from the cursor, the result is provided asynchronously to the handler.
Class Method Details
+ (Boolean) accept?(obj)
Returns:
(Boolean)
18
19
20
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_cursor.rb', line 18def@@j_api_type.accept?(obj)obj.class==PgCursorend
+ (Object) j_api_type
27
28
29
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_cursor.rb', line 27defself.j_api_type@@j_api_typeend
+ (Object) j_class
30
31
32
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_cursor.rb', line 30defself.j_classJava::IoReactiversePgclient::PgCursor.java_classend
+ (Object) unwrap(obj)
24
25
26
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_cursor.rb', line 24def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
21
22
23
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_cursor.rb', line 21def@@j_api_type.wrap(obj)PgCursor.new(obj)end
Instance Method Details
- (void) close { ... }
This method returns an undefined value.
Like #close but with a completionHandler called when the cursor has been released.
Yields:
Raises:
(ArgumentError)
55
56
57
58
59
60
61
62
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_cursor.rb', line 55defcloseif!block_given?return@j_del.java_method(:close,[]).call()elsifblock_given?return@j_del.java_method(:close,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil)}))endraiseArgumentError,"Invalid arguments when calling close()"end
- (true, false) has_more?
Returns true when the cursor has results in progress and the should be called to retrieve
them.
Returns:
(true, false)
—
whether the cursor has more results,
Raises:
(ArgumentError)
46
47
48
49
50
51
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_cursor.rb', line 46defhas_more?if!block_given?return@j_del.java_method(:hasMore,[]).call()endraiseArgumentError,"Invalid arguments when calling has_more?()"end
- (void) read(count = nil) { ... }
This method returns an undefined value.
Read rows from the cursor, the result is provided asynchronously to the handler.
Parameters:
count(Fixnum)(defaults to: nil)
—
the amount of rows to read
Yields:
the handler for the result
Raises:
(ArgumentError)
37
38
39
40
41
42
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_cursor.rb', line 37defread(count=nil)ifcount.class==Fixnum&&block_given?return@j_del.java_method(:read,[Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(count,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))endraiseArgumentError,"Invalid arguments when calling read(#{count})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_iterator.rb', line 18def@@j_api_type.accept?(obj)obj.class==PgIteratorend
+ (Object) j_api_type
27
28
29
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_iterator.rb', line 27defself.j_api_type@@j_api_typeend
+ (Object) j_class
30
31
32
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_iterator.rb', line 30defself.j_classJava::IoReactiversePgclient::PgIterator.java_classend
+ (Object) unwrap(obj)
24
25
26
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_iterator.rb', line 24def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
21
22
23
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_iterator.rb', line 21def@@j_api_type.wrap(obj)PgIterator.new(obj)end
Instance Method Details
- (true, false) has_next?
Returns:
(true, false)
Raises:
(ArgumentError)
34
35
36
37
38
39
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_iterator.rb', line 34defhas_next?if!block_given?return@j_del.java_method(:hasNext,[]).call()endraiseArgumentError,"Invalid arguments when calling has_next?()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_iterator.rb', line 41defnextif!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:next,[]).call(),::ReactivePgClient::Row)endraiseArgumentError,"Invalid arguments when calling next()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 23def@@j_api_type.accept?(obj)obj.class==PgPoolend
+ (Object) j_api_type
32
33
34
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 32defself.j_api_type@@j_api_typeend
+ (Object) j_class
35
36
37
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 35defself.j_classJava::IoReactiversePgclient::PgPool.java_classend
+ (Object) unwrap(obj)
29
30
31
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 29def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
26
27
28
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 26def@@j_api_type.wrap(obj)PgPool.new(obj)end
Instance Method Details
- (void) begin { ... }
This method returns an undefined value.
Borrow a connection from the pool and begin a transaction, the underlying connection will be returned
to the pool when the transaction ends.
Yields:
Raises:
(ArgumentError)
86
87
88
89
90
91
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 86defbeginifblock_given?return@j_del.java_method(:begin,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgTransaction):nil)}))endraiseArgumentError,"Invalid arguments when calling begin()"end
- (void) close
This method returns an undefined value.
Close the pool and release the associated resources.
Raises:
(ArgumentError)
94
95
96
97
98
99
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 94defcloseif!block_given?return@j_del.java_method(:close,[]).call()endraiseArgumentError,"Invalid arguments when calling close()"end
- (void) get_connection { ... }
This method returns an undefined value.
Get a connection from the pool.
Yields:
the handler that will get the connection result
Raises:
(ArgumentError)
76
77
78
79
80
81
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 76defget_connectionifblock_given?return@j_del.java_method(:getConnection,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgConnection):nil)}))endraiseArgumentError,"Invalid arguments when calling get_connection()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 66defprepared_batch(sql=nil,batch=nil)ifsql.class==String&&batch.class==Array&&block_given?@j_del.java_method(:preparedBatch,[Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,batch.map{|element|element.j_del},(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepared_batch(#{sql},#{batch})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 42defprepared_query(sql=nil,arguments=nil)ifsql.class==String&&block_given?&&arguments==nil@j_del.java_method(:preparedQuery,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfelsifsql.class==String&&arguments.class.method_defined?(:j_del)&&block_given?@j_del.java_method(:preparedQuery,[Java::java.lang.String.java_class,Java::IoReactiversePgclient::Tuple.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,arguments.j_del,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepared_query(#{sql},#{arguments})"end
- (self) query(sql = nil) { ... }
Parameters:
sql(String)(defaults to: nil)
Yields:
Returns:
(self)
Raises:
(ArgumentError)
55
56
57
58
59
60
61
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_pool.rb', line 55defquery(sql=nil)ifsql.class==String&&block_given?@j_del.java_method(:query,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling query(#{sql})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 22def@@j_api_type.accept?(obj)obj.class==PgPreparedQueryend
+ (Object) j_api_type
31
32
33
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 31defself.j_api_type@@j_api_typeend
+ (Object) j_class
34
35
36
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 34defself.j_classJava::IoReactiversePgclient::PgPreparedQuery.java_classend
+ (Object) unwrap(obj)
28
29
30
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 28def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
25
26
27
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 25def@@j_api_type.wrap(obj)PgPreparedQuery.new(obj)end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 79defbatch(argsList=nil)ifargsList.class==Array&&block_given?@j_del.java_method(:batch,[Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(argsList.map{|element|element.j_del},(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling batch(#{argsList})"end
- (void) close { ... }
This method returns an undefined value.
Like #close but notifies the completionHandler when it's closed.
Yields:
Raises:
(ArgumentError)
89
90
91
92
93
94
95
96
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 89defcloseif!block_given?return@j_del.java_method(:close,[]).call()elsifblock_given?return@j_del.java_method(:close,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil)}))endraiseArgumentError,"Invalid arguments when calling close()"end
Execute the prepared query with a cursor and createStream the result. The createStream opens a cursor
with a fetch size to fetch the results.
Note: this requires to be in a transaction, since cursors require it.
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 69defcreate_stream(fetch=nil,args=nil)iffetch.class==Fixnum&&args.class.method_defined?(:j_del)&&!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:createStream,[Java::int.java_class,Java::IoReactiversePgclient::Tuple.java_class]).call(fetch,args.j_del),::ReactivePgClient::PgStream,::ReactivePgClient::Row.j_api_type)endraiseArgumentError,"Invalid arguments when calling create_stream(#{fetch},#{args})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 54defcursor(args=nil)if!block_given?&&args==nilreturn::Vertx::Util::Utils.safe_create(@j_del.java_method(:cursor,[]).call(),::ReactivePgClient::PgCursor)elsifargs.class.method_defined?(:j_del)&&!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:cursor,[Java::IoReactiversePgclient::Tuple.java_class]).call(args.j_del),::ReactivePgClient::PgCursor)endraiseArgumentError,"Invalid arguments when calling cursor(#{args})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_prepared_query.rb', line 41defexecute(args=nil)ifblock_given?&&args==nil@j_del.java_method(:execute,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfelsifargs.class.method_defined?(:j_del)&&block_given?@j_del.java_method(:execute,[Java::IoReactiversePgclient::Tuple.java_class,Java::IoVertxCore::Handler.java_class]).call(args.j_del,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling execute(#{args})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_result.rb', line 35defcolumns_namesif!block_given?return@j_del.java_method(:columnsNames,[]).call().to_a.map{|elt|elt}endraiseArgumentError,"Invalid arguments when calling columns_names()"end
the next available result or null if none is available
Raises:
(ArgumentError)
60
61
62
63
64
65
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_result.rb', line 60defnextif!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:next,[]).call(),::ReactivePgClient::PgResult,nil)endraiseArgumentError,"Invalid arguments when calling next()"end
- (Fixnum) row_count
Get the number of the affected rows in the operation to this PgResult.
The meaning depends on the executed statement:
INSERT: the number of rows inserted
DELETE: the number of rows deleted
UPDATE: the number of rows updated
SELECT: the number of rows retrieved
Returns:
(Fixnum)
—
the count of affected rows.
Raises:
(ArgumentError)
27
28
29
30
31
32
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_result.rb', line 27defrow_countif!block_given?return@j_del.java_method(:rowCount,[]).call()endraiseArgumentError,"Invalid arguments when calling row_count()"end
- (Fixnum) size
Get the number of rows in the PgResult.
Returns:
(Fixnum)
—
the count of rows.
Raises:
(ArgumentError)
43
44
45
46
47
48
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_result.rb', line 43defsizeif!block_given?return@j_del.java_method(:size,[]).call()endraiseArgumentError,"Invalid arguments when calling size()"end
- (Object) value
Get the result value.
Returns:
(Object)
—
the result
Raises:
(ArgumentError)
51
52
53
54
55
56
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_result.rb', line 51defvalueif!block_given?return@j_arg_T.wrap(@j_del.java_method(:value,[]).call())endraiseArgumentError,"Invalid arguments when calling value()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 21def@@j_api_type.accept?(obj)obj.class==PgRowSetend
+ (Object) j_api_type
30
31
32
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 30defself.j_api_type@@j_api_typeend
+ (Object) j_class
33
34
35
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 33defself.j_classJava::IoReactiversePgclient::PgRowSet.java_classend
+ (Object) unwrap(obj)
27
28
29
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 27def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
24
25
26
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 24def@@j_api_type.wrap(obj)PgRowSet.new(obj)end
Instance Method Details
- (Array<String>) columns_names
Get the names of columns in the PgResult.
Returns:
(Array<String>)
—
the list of names of columns.
Raises:
(ArgumentError)
54
55
56
57
58
59
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 54defcolumns_namesif!block_given?return@j_del.java_method(:columnsNames,[]).call().to_a.map{|elt|elt}endraiseArgumentError,"Invalid arguments when calling columns_names()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 77defiteratorif!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:iterator,[]).call(),::ReactivePgClient::PgIterator)endraiseArgumentError,"Invalid arguments when calling iterator()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 84defnextif!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:next,[]).call(),::ReactivePgClient::PgRowSet)endraiseArgumentError,"Invalid arguments when calling next()"end
- (Fixnum) row_count
Get the number of the affected rows in the operation to this PgResult.
The meaning depends on the executed statement:
INSERT: the number of rows inserted
DELETE: the number of rows deleted
UPDATE: the number of rows updated
SELECT: the number of rows retrieved
Returns:
(Fixnum)
—
the count of affected rows.
Raises:
(ArgumentError)
46
47
48
49
50
51
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 46defrow_countif!block_given?return@j_del.java_method(:rowCount,[]).call()endraiseArgumentError,"Invalid arguments when calling row_count()"end
- (Fixnum) size
Get the number of rows in the PgResult.
Returns:
(Fixnum)
—
the count of rows.
Raises:
(ArgumentError)
62
63
64
65
66
67
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 62defsizeif!block_given?return@j_del.java_method(:size,[]).call()endraiseArgumentError,"Invalid arguments when calling size()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_row_set.rb', line 70defvalueif!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:value,[]).call(),::ReactivePgClient::PgRowSet)endraiseArgumentError,"Invalid arguments when calling value()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_stream.rb', line 74defcloseif!block_given?return@j_del.java_method(:close,[]).call()elsifblock_given?return@j_del.java_method(:close,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil)}))endraiseArgumentError,"Invalid arguments when calling close()"end
- (self) end_handler { ... }
Yields:
Returns:
(self)
Raises:
(ArgumentError)
64
65
66
67
68
69
70
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_stream.rb', line 64defend_handlerifblock_given?@j_del.java_method(:endHandler,[Java::IoVertxCore::Handler.java_class]).call(Proc.new{yield})returnselfendraiseArgumentError,"Invalid arguments when calling end_handler()"end
- (self) exception_handler { ... }
Yields:
Returns:
(self)
Raises:
(ArgumentError)
30
31
32
33
34
35
36
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_stream.rb', line 30defexception_handlerifblock_given?@j_del.java_method(:exceptionHandler,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|event|yield(::Vertx::Util::Utils.from_throwable(event))}))returnselfendraiseArgumentError,"Invalid arguments when calling exception_handler()"end
- (self) fetch(arg0 = nil)
Parameters:
arg0(Fixnum)(defaults to: nil)
Returns:
(self)
Raises:
(ArgumentError)
21
22
23
24
25
26
27
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_stream.rb', line 21deffetch(arg0=nil)ifarg0.class==Fixnum&&!block_given?@j_del.java_method(:fetch,[Java::long.java_class]).call(arg0)returnselfendraiseArgumentError,"Invalid arguments when calling fetch(#{arg0})"end
- (self) handler { ... }
Yields:
Returns:
(self)
Raises:
(ArgumentError)
39
40
41
42
43
44
45
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_stream.rb', line 39defhandlerifblock_given?@j_del.java_method(:handler,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|event|yield(@j_arg_T.wrap(event))}))returnselfendraiseArgumentError,"Invalid arguments when calling handler()"end
- (self) pause
Returns:
(self)
Raises:
(ArgumentError)
47
48
49
50
51
52
53
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_stream.rb', line 47defpauseif!block_given?@j_del.java_method(:pause,[]).call()returnselfendraiseArgumentError,"Invalid arguments when calling pause()"end
- (self) resume
Returns:
(self)
Raises:
(ArgumentError)
55
56
57
58
59
60
61
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_stream.rb', line 55defresumeif!block_given?@j_del.java_method(:resume,[]).call()returnselfendraiseArgumentError,"Invalid arguments when calling resume()"end
Set the reconnect policy that is executed when the subscriber is disconnected.
Class Method Details
+ (Boolean) accept?(obj)
Returns:
(Boolean)
22
23
24
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 22def@@j_api_type.accept?(obj)obj.class==PgSubscriberend
+ (Object) j_api_type
31
32
33
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 31defself.j_api_type@@j_api_typeend
+ (Object) j_class
34
35
36
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 34defself.j_classJava::IoReactiversePgclientPubsub::PgSubscriber.java_classend
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 41defself.subscriber(vertx=nil,options=nil)ifvertx.class.method_defined?(:j_del)&&options.class==Hash&&!block_given?return::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclientPubsub::PgSubscriber.java_method(:subscriber,[Java::IoVertxCore::Vertx.java_class,Java::IoReactiversePgclient::PgConnectOptions.java_class]).call(vertx.j_del,Java::IoReactiversePgclient::PgConnectOptions.new(::Vertx::Util::Utils.to_json_object(options))),::ReactivePgClient::PgSubscriber)endraiseArgumentError,"Invalid arguments when calling subscriber(#{vertx},#{options})"end
+ (Object) unwrap(obj)
28
29
30
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 28def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
25
26
27
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 25def@@j_api_type.wrap(obj)PgSubscriber.new(obj)end
the actual connection to Postgres, it might be null
Raises:
(ArgumentError)
97
98
99
100
101
102
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 97defactual_connectionif!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:actualConnection,[]).call(),::ReactivePgClient::PgConnection)endraiseArgumentError,"Invalid arguments when calling actual_connection()"end
the channel name This will be the name of the channel exactly as held by Postgres for sending notifications. Internally this name will be truncated to the Postgres identifier maxiumum length of (NAMEDATALEN = 64) - 1 == 63 characters, and prepared as a quoted identifier without unicode escape sequence support for use in LISTEN/UNLISTEN commands. Examples of channel names and corresponding NOTIFY commands:
when name == "the_channel": NOTIFY the_channel, 'msg', NOTIFY The_Channel, 'msg', or NOTIFY "the_channel", 'msg' succeed in delivering a message to the created channel
when name == "The_Channel": NOTIFY "The_Channel", 'msg', succeeds in delivering a message to the created channel
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 50defchannel(name=nil)ifname.class==String&&!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:channel,[Java::java.lang.String.java_class]).call(name),::ReactivePgClient::PgChannel)endraiseArgumentError,"Invalid arguments when calling channel(#{name})"end
- (void) close
This method returns an undefined value.
Close the subscriber, the retry policy will not be invoked.
Raises:
(ArgumentError)
112
113
114
115
116
117
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 112defcloseif!block_given?return@j_del.java_method(:close,[]).call()endraiseArgumentError,"Invalid arguments when calling close()"end
- (self) close_handler { ... }
Set an handler called when the subscriber is closed.
Yields:
the handler
Returns:
(self)
Raises:
(ArgumentError)
89
90
91
92
93
94
95
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 89defclose_handlerifblock_given?@j_del.java_method(:closeHandler,[Java::IoVertxCore::Handler.java_class]).call(Proc.new{yield})returnselfendraiseArgumentError,"Invalid arguments when calling close_handler()"end
- (true, false) closed?
Returns whether the subscriber is closed
Returns:
(true, false)
—
whether the subscriber is closed
Raises:
(ArgumentError)
104
105
106
107
108
109
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 104defclosed?if!block_given?return@j_del.java_method(:closed,[]).call()endraiseArgumentError,"Invalid arguments when calling closed?()"end
- (self) connect { ... }
Connect the subscriber to Postgres.
Yields:
the handler notified of the connection success or failure
Returns:
(self)
Raises:
(ArgumentError)
59
60
61
62
63
64
65
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 59defconnectifblock_given?@j_del.java_method(:connect,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling connect()"end
- (self) reconnect_policy(policy = nil) { ... }
Set the reconnect policy that is executed when the subscriber is disconnected.
When the subscriber is disconnected, the policy function is called with the actual
number of retries and returns an amountOfTime value:
when amountOfTime < 0: the subscriber is closed and there is no retry
when amountOfTime == 0: the subscriber retries to connect immediately
when amountOfTime > 0: the subscriber retries after amountOfTime milliseconds
The default policy does not perform any retries.
Yields:
the policy to set
Returns:
(self)
Raises:
(ArgumentError)
79
80
81
82
83
84
85
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_subscriber.rb', line 79defreconnect_policy(policy=nil)ifblock_given?&&policy==nil@j_del.java_method(:reconnectPolicy,[Java::JavaUtilFunction::Function.java_class]).call((Proc.new{|event|yield(event)}))returnselfendraiseArgumentError,"Invalid arguments when calling reconnect_policy(#{policy})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 22def@@j_api_type.accept?(obj)obj.class==PgTransactionend
+ (Object) j_api_type
31
32
33
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 31defself.j_api_type@@j_api_typeend
+ (Object) j_class
34
35
36
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 34defself.j_classJava::IoReactiversePgclient::PgTransaction.java_classend
+ (Object) unwrap(obj)
28
29
30
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 28def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
25
26
27
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 25def@@j_api_type.wrap(obj)PgTransaction.new(obj)end
Instance Method Details
- (self) abort_handler { ... }
Set an handler to be called when the transaction is aborted.
Yields:
the handler
Returns:
(self)
Raises:
(ArgumentError)
73
74
75
76
77
78
79
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 73defabort_handlerifblock_given?@j_del.java_method(:abortHandler,[Java::IoVertxCore::Handler.java_class]).call(Proc.new{yield})returnselfendraiseArgumentError,"Invalid arguments when calling abort_handler()"end
- (void) commit { ... }
This method returns an undefined value.
Like #commit with an handler to be notified when the transaction commit has completed
Yields:
Raises:
(ArgumentError)
51
52
53
54
55
56
57
58
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 51defcommitif!block_given?return@j_del.java_method(:commit,[]).call()elsifblock_given?return@j_del.java_method(:commit,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil)}))endraiseArgumentError,"Invalid arguments when calling commit()"end
- (self) prepare(sql = nil) { ... }
Create a prepared query.
Parameters:
sql(String)(defaults to: nil)
—
the sql
Yields:
the handler notified with the prepared query asynchronously
Returns:
(self)
Raises:
(ArgumentError)
41
42
43
44
45
46
47
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 41defprepare(sql=nil)ifsql.class==String&&block_given?@j_del.java_method(:prepare,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgPreparedQuery):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepare(#{sql})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 108defprepared_batch(sql=nil,batch=nil)ifsql.class==String&&batch.class==Array&&block_given?@j_del.java_method(:preparedBatch,[Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,batch.map{|element|element.j_del},(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepared_batch(#{sql},#{batch})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 94defprepared_query(sql=nil,arguments=nil)ifsql.class==String&&block_given?&&arguments==nil@j_del.java_method(:preparedQuery,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfelsifsql.class==String&&arguments.class.method_defined?(:j_del)&&block_given?@j_del.java_method(:preparedQuery,[Java::java.lang.String.java_class,Java::IoReactiversePgclient::Tuple.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,arguments.j_del,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling prepared_query(#{sql},#{arguments})"end
- (self) query(sql = nil) { ... }
Parameters:
sql(String)(defaults to: nil)
Yields:
Returns:
(self)
Raises:
(ArgumentError)
83
84
85
86
87
88
89
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 83defquery(sql=nil)ifsql.class==String&&block_given?@j_del.java_method(:query,[Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new{|ar|yield(ar.failed?ar.cause:nil,ar.succeeded?::Vertx::Util::Utils.safe_create(ar.result,::ReactivePgClient::PgRowSet):nil)}))returnselfendraiseArgumentError,"Invalid arguments when calling query(#{sql})"end
- (void) rollback { ... }
This method returns an undefined value.
Like #rollback with an handler to be notified when the transaction rollback has completed
Yields:
Raises:
(ArgumentError)
62
63
64
65
66
67
68
69
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/pg_transaction.rb', line 62defrollbackif!block_given?return@j_del.java_method(:rollback,[]).call()elsifblock_given?return@j_del.java_method(:rollback,[Java::IoVertxCore::Handler.java_class]).call((Proc.new{|ar|yield(ar.failed?ar.cause:nil)}))endraiseArgumentError,"Invalid arguments when calling rollback()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 20def@@j_api_type.accept?(obj)obj.class==Rowend
+ (Object) j_api_type
29
30
31
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 29defself.j_api_type@@j_api_typeend
+ (Object) j_class
32
33
34
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 32defself.j_classJava::IoReactiversePgclient::Row.java_classend
+ (Object) unwrap(obj)
26
27
28
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 26def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
23
24
25
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 23def@@j_api_type.wrap(obj)Row.new(obj)end
Instance Method Details
- (self) add_boolean(value = nil)
Add a boolean value at the end of the tuple.
Parameters:
value(true, false)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
290
291
292
293
294
295
296
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 290defadd_boolean(value=nil)if(value.class==TrueClass||value.class==FalseClass)&&!block_given?@j_del.java_method(:addBoolean,[Java::JavaLang::Boolean.java_class]).call(value)returnselfendraiseArgumentError,"Invalid arguments when calling add_boolean(#{value})"end
- (self) add_box(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
420
421
422
423
424
425
426
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 420defadd_box(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addBox,[Java::IoReactiversePgclientData::Box.java_class]).call(Java::IoReactiversePgclientData::Box.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_box(#{value})"end
- (self) add_buffer(value = nil)
Add a buffer value at the end of the tuple.
Parameters:
value(::Vertx::Buffer)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
380
381
382
383
384
385
386
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 380defadd_buffer(value=nil)ifvalue.class.method_defined?(:j_del)&&!block_given?@j_del.java_method(:addBuffer,[Java::IoVertxCoreBuffer::Buffer.java_class]).call(value.j_del)returnselfendraiseArgumentError,"Invalid arguments when calling add_buffer(#{value})"end
- (self) add_circle(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
450
451
452
453
454
455
456
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 450defadd_circle(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addCircle,[Java::IoReactiversePgclientData::Circle.java_class]).call(Java::IoReactiversePgclientData::Circle.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_circle(#{value})"end
- (self) add_double(value = nil)
Add a double value at the end of the tuple.
Parameters:
value(Float)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
350
351
352
353
354
355
356
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 350defadd_double(value=nil)ifvalue.class==Float&&!block_given?@j_del.java_method(:addDouble,[Java::JavaLang::Double.java_class]).call(::Vertx::Util::Utils.to_double(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_double(#{value})"end
- (self) add_float(value = nil)
Add a float value at the end of the tuple.
Parameters:
value(Float)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
340
341
342
343
344
345
346
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 340defadd_float(value=nil)ifvalue.class==Float&&!block_given?@j_del.java_method(:addFloat,[Java::JavaLang::Float.java_class]).call(::Vertx::Util::Utils.to_float(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_float(#{value})"end
- (self) add_integer(value = nil)
Add an integer value at the end of the tuple.
Parameters:
value(Fixnum)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
320
321
322
323
324
325
326
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 320defadd_integer(value=nil)ifvalue.class==Fixnum&&!block_given?@j_del.java_method(:addInteger,[Java::JavaLang::Integer.java_class]).call(::Vertx::Util::Utils.to_integer(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_integer(#{value})"end
- (self) add_interval(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
460
461
462
463
464
465
466
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 460defadd_interval(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addInterval,[Java::IoReactiversePgclientData::Interval.java_class]).call(Java::IoReactiversePgclientData::Interval.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_interval(#{value})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 370defadd_json(value=nil)ifvalue.class.method_defined?(:j_del)&&!block_given?@j_del.java_method(:addJson,[Java::IoReactiversePgclientData::Json.java_class]).call(value.j_del)returnselfendraiseArgumentError,"Invalid arguments when calling add_json(#{value})"end
- (self) add_line(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
400
401
402
403
404
405
406
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 400defadd_line(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addLine,[Java::IoReactiversePgclientData::Line.java_class]).call(Java::IoReactiversePgclientData::Line.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_line(#{value})"end
- (self) add_line_segment(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
410
411
412
413
414
415
416
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 410defadd_line_segment(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addLineSegment,[Java::IoReactiversePgclientData::LineSegment.java_class]).call(Java::IoReactiversePgclientData::LineSegment.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_line_segment(#{value})"end
- (self) add_long(value = nil)
Add a long value at the end of the tuple.
Parameters:
value(Fixnum)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
330
331
332
333
334
335
336
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 330defadd_long(value=nil)ifvalue.class==Fixnum&&!block_given?@j_del.java_method(:addLong,[Java::JavaLang::Long.java_class]).call(value)returnselfendraiseArgumentError,"Invalid arguments when calling add_long(#{value})"end
- (self) add_path(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
430
431
432
433
434
435
436
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 430defadd_path(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addPath,[Java::IoReactiversePgclientData::Path.java_class]).call(Java::IoReactiversePgclientData::Path.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_path(#{value})"end
- (self) add_point(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
390
391
392
393
394
395
396
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 390defadd_point(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addPoint,[Java::IoReactiversePgclientData::Point.java_class]).call(Java::IoReactiversePgclientData::Point.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_point(#{value})"end
- (self) add_polygon(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
440
441
442
443
444
445
446
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 440defadd_polygon(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addPolygon,[Java::IoReactiversePgclientData::Polygon.java_class]).call(Java::IoReactiversePgclientData::Polygon.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_polygon(#{value})"end
- (self) add_short(value = nil)
Add a short value at the end of the tuple.
Parameters:
value(Fixnum)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
310
311
312
313
314
315
316
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 310defadd_short(value=nil)ifvalue.class==Fixnum&&!block_given?@j_del.java_method(:addShort,[Java::JavaLang::Short.java_class]).call(::Vertx::Util::Utils.to_short(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_short(#{value})"end
- (self) add_string(value = nil)
Add a string value at the end of the tuple.
Parameters:
value(String)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
360
361
362
363
364
365
366
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 360defadd_string(value=nil)ifvalue.class==String&&!block_given?@j_del.java_method(:addString,[Java::java.lang.String.java_class]).call(value)returnselfendraiseArgumentError,"Invalid arguments when calling add_string(#{value})"end
- (self) add_value(value = nil)
Add an object value at the end of the tuple.
Parameters:
value(Object)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
300
301
302
303
304
305
306
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 300defadd_value(value=nil)if::Vertx::Util::unknown_type.accept?(value)&&!block_given?@j_del.java_method(:addValue,[Java::java.lang.Object.java_class]).call(::Vertx::Util::Utils.to_object(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_value(#{value})"end
- (void) clear
This method returns an undefined value.
Raises:
(ArgumentError)
475
476
477
478
479
480
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 475defclearif!block_given?return@j_del.java_method(:clear,[]).call()endraiseArgumentError,"Invalid arguments when calling clear()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 41defget_boolean?(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getBoolean,[Java::int.java_class]).call(param_1)elsifparam_1.class==String&&!block_given?return@j_del.java_method(:getBoolean,[Java::java.lang.String.java_class]).call(param_1)endraiseArgumentError,"Invalid arguments when calling get_boolean?(#{param_1})"end
- (Hash) getBox(pos) - (Hash) getBox(name)
Get value at pos.
Overloads:
- (Hash) getBox(pos)
Parameters:
pos(Fixnum)
—
the position
- (Hash) getBox(name)
Parameters:
name(String)
—
the column
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
209
210
211
212
213
214
215
216
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 209defget_box(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getBox,[Java::int.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getBox,[Java::int.java_class]).call(param_1).toJson.encode):nilelsifparam_1.class==String&&!block_given?return@j_del.java_method(:getBox,[Java::java.lang.String.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getBox,[Java::java.lang.String.java_class]).call(param_1).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_box(#{param_1})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 279defget_buffer(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:getBuffer,[Java::int.java_class]).call(param_1),::Vertx::Buffer)elsifparam_1.class==String&&!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:getBuffer,[Java::java.lang.String.java_class]).call(param_1),::Vertx::Buffer)endraiseArgumentError,"Invalid arguments when calling get_buffer(#{param_1})"end
- (Hash) getCircle(pos) - (Hash) getCircle(name)
Get value at pos.
Overloads:
- (Hash) getCircle(pos)
Parameters:
pos(Fixnum)
—
the position
- (Hash) getCircle(name)
Parameters:
name(String)
—
the column
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
251
252
253
254
255
256
257
258
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 251defget_circle(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getCircle,[Java::int.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getCircle,[Java::int.java_class]).call(param_1).toJson.encode):nilelsifparam_1.class==String&&!block_given?return@j_del.java_method(:getCircle,[Java::java.lang.String.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getCircle,[Java::java.lang.String.java_class]).call(param_1).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_circle(#{param_1})"end
- (String) get_column_name(pos = nil)
Get a column name at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(String)
—
the column name or null
Raises:
(ArgumentError)
484
485
486
487
488
489
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 484defget_column_name(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getColumnName,[Java::int.java_class]).call(pos)endraiseArgumentError,"Invalid arguments when calling get_column_name(#{pos})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 125defget_double(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getDouble,[Java::int.java_class]).call(param_1)elsifparam_1.class==String&&!block_given?return@j_del.java_method(:getDouble,[Java::java.lang.String.java_class]).call(param_1)endraiseArgumentError,"Invalid arguments when calling get_double(#{param_1})"end
- (Float) getFloat(pos) - (Float) getFloat(name)
Get a float value at pos.
Overloads:
- (Float) getFloat(pos)
Parameters:
pos(Fixnum)
—
the position
- (Float) getFloat(name)
Parameters:
name(String)
—
the column
Returns:
(Float)
—
the value or null
Raises:
(ArgumentError)
111
112
113
114
115
116
117
118
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 111defget_float(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getFloat,[Java::int.java_class]).call(param_1)elsifparam_1.class==String&&!block_given?return@j_del.java_method(:getFloat,[Java::java.lang.String.java_class]).call(param_1)endraiseArgumentError,"Invalid arguments when calling get_float(#{param_1})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 83defget_integer(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getInteger,[Java::int.java_class]).call(param_1)elsifparam_1.class==String&&!block_given?return@j_del.java_method(:getInteger,[Java::java.lang.String.java_class]).call(param_1)endraiseArgumentError,"Invalid arguments when calling get_integer(#{param_1})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 265defget_interval(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getInterval,[Java::int.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getInterval,[Java::int.java_class]).call(param_1).toJson.encode):nilelsifparam_1.class==String&&!block_given?return@j_del.java_method(:getInterval,[Java::java.lang.String.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getInterval,[Java::java.lang.String.java_class]).call(param_1).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_interval(#{param_1})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 153defget_json(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:getJson,[Java::int.java_class]).call(param_1),::ReactivePgClient::Json)elsifparam_1.class==String&&!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:getJson,[Java::java.lang.String.java_class]).call(param_1),::ReactivePgClient::Json)endraiseArgumentError,"Invalid arguments when calling get_json(#{param_1})"end
- (Hash) getLine(pos) - (Hash) getLine(name)
Get value at pos.
Overloads:
- (Hash) getLine(pos)
Parameters:
pos(Fixnum)
—
the position
- (Hash) getLine(name)
Parameters:
name(String)
—
the column
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
181
182
183
184
185
186
187
188
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 181defget_line(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getLine,[Java::int.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getLine,[Java::int.java_class]).call(param_1).toJson.encode):nilelsifparam_1.class==String&&!block_given?return@j_del.java_method(:getLine,[Java::java.lang.String.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getLine,[Java::java.lang.String.java_class]).call(param_1).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_line(#{param_1})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 195defget_line_segment(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getLineSegment,[Java::int.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getLineSegment,[Java::int.java_class]).call(param_1).toJson.encode):nilelsifparam_1.class==String&&!block_given?return@j_del.java_method(:getLineSegment,[Java::java.lang.String.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getLineSegment,[Java::java.lang.String.java_class]).call(param_1).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_line_segment(#{param_1})"end
- (Fixnum) getLong(pos) - (Fixnum) getLong(name)
Get a long value at pos.
Overloads:
- (Fixnum) getLong(pos)
Parameters:
pos(Fixnum)
—
the position
- (Fixnum) getLong(name)
Parameters:
name(String)
—
the column
Returns:
(Fixnum)
—
the value or null
Raises:
(ArgumentError)
97
98
99
100
101
102
103
104
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 97defget_long(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getLong,[Java::int.java_class]).call(param_1)elsifparam_1.class==String&&!block_given?return@j_del.java_method(:getLong,[Java::java.lang.String.java_class]).call(param_1)endraiseArgumentError,"Invalid arguments when calling get_long(#{param_1})"end
- (Hash) getPath(pos) - (Hash) getPath(name)
Get value at pos.
Overloads:
- (Hash) getPath(pos)
Parameters:
pos(Fixnum)
—
the position
- (Hash) getPath(name)
Parameters:
name(String)
—
the column
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
223
224
225
226
227
228
229
230
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 223defget_path(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getPath,[Java::int.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getPath,[Java::int.java_class]).call(param_1).toJson.encode):nilelsifparam_1.class==String&&!block_given?return@j_del.java_method(:getPath,[Java::java.lang.String.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getPath,[Java::java.lang.String.java_class]).call(param_1).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_path(#{param_1})"end
- (Hash) getPoint(pos) - (Hash) getPoint(name)
Get value at pos.
Overloads:
- (Hash) getPoint(pos)
Parameters:
pos(Fixnum)
—
the position
- (Hash) getPoint(name)
Parameters:
name(String)
—
the column
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
167
168
169
170
171
172
173
174
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 167defget_point(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getPoint,[Java::int.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getPoint,[Java::int.java_class]).call(param_1).toJson.encode):nilelsifparam_1.class==String&&!block_given?return@j_del.java_method(:getPoint,[Java::java.lang.String.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getPoint,[Java::java.lang.String.java_class]).call(param_1).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_point(#{param_1})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 237defget_polygon(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getPolygon,[Java::int.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getPolygon,[Java::int.java_class]).call(param_1).toJson.encode):nilelsifparam_1.class==String&&!block_given?return@j_del.java_method(:getPolygon,[Java::java.lang.String.java_class]).call(param_1)!=nil?JSON.parse(@j_del.java_method(:getPolygon,[Java::java.lang.String.java_class]).call(param_1).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_polygon(#{param_1})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 69defget_short(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getShort,[Java::int.java_class]).call(param_1)elsifparam_1.class==String&&!block_given?return@j_del.java_method(:getShort,[Java::java.lang.String.java_class]).call(param_1)endraiseArgumentError,"Invalid arguments when calling get_short(#{param_1})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 139defget_string(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return@j_del.java_method(:getString,[Java::int.java_class]).call(param_1)elsifparam_1.class==String&&!block_given?return@j_del.java_method(:getString,[Java::java.lang.String.java_class]).call(param_1)endraiseArgumentError,"Invalid arguments when calling get_string(#{param_1})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 55defget_value(param_1=nil)ifparam_1.class==Fixnum&&!block_given?return::Vertx::Util::Utils.from_object(@j_del.java_method(:getValue,[Java::int.java_class]).call(param_1))elsifparam_1.class==String&&!block_given?return::Vertx::Util::Utils.from_object(@j_del.java_method(:getValue,[Java::java.lang.String.java_class]).call(param_1))endraiseArgumentError,"Invalid arguments when calling get_value(#{param_1})"end
- (Fixnum) size
Returns the tuple size
Returns:
(Fixnum)
—
the tuple size
Raises:
(ArgumentError)
468
469
470
471
472
473
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/row.rb', line 468defsizeif!block_given?return@j_del.java_method(:size,[]).call()endraiseArgumentError,"Invalid arguments when calling size()"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 19def@@j_api_type.accept?(obj)obj.class==Tupleend
+ (Object) j_api_type
28
29
30
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 28defself.j_api_type@@j_api_typeend
+ (Object) j_class
31
32
33
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 31defself.j_classJava::IoReactiversePgclient::Tuple.java_classend
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 49defself.of(elt1=nil,elt2=nil,elt3=nil,elt4=nil,elt5=nil,elt6=nil)if::Vertx::Util::unknown_type.accept?(elt1)&&!block_given?&&elt2==nil&&elt3==nil&&elt4==nil&&elt5==nil&&elt6==nilreturn::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::Tuple.java_method(:of,[Java::java.lang.Object.java_class]).call(::Vertx::Util::Utils.to_object(elt1)),::ReactivePgClient::Tuple)elsif::Vertx::Util::unknown_type.accept?(elt1)&&::Vertx::Util::unknown_type.accept?(elt2)&&!block_given?&&elt3==nil&&elt4==nil&&elt5==nil&&elt6==nilreturn::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::Tuple.java_method(:of,[Java::java.lang.Object.java_class,Java::java.lang.Object.java_class]).call(::Vertx::Util::Utils.to_object(elt1),::Vertx::Util::Utils.to_object(elt2)),::ReactivePgClient::Tuple)elsif::Vertx::Util::unknown_type.accept?(elt1)&&::Vertx::Util::unknown_type.accept?(elt2)&&::Vertx::Util::unknown_type.accept?(elt3)&&!block_given?&&elt4==nil&&elt5==nil&&elt6==nilreturn::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::Tuple.java_method(:of,[Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class]).call(::Vertx::Util::Utils.to_object(elt1),::Vertx::Util::Utils.to_object(elt2),::Vertx::Util::Utils.to_object(elt3)),::ReactivePgClient::Tuple)elsif::Vertx::Util::unknown_type.accept?(elt1)&&::Vertx::Util::unknown_type.accept?(elt2)&&::Vertx::Util::unknown_type.accept?(elt3)&&::Vertx::Util::unknown_type.accept?(elt4)&&!block_given?&&elt5==nil&&elt6==nilreturn::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::Tuple.java_method(:of,[Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class]).call(::Vertx::Util::Utils.to_object(elt1),::Vertx::Util::Utils.to_object(elt2),::Vertx::Util::Utils.to_object(elt3),::Vertx::Util::Utils.to_object(elt4)),::ReactivePgClient::Tuple)elsif::Vertx::Util::unknown_type.accept?(elt1)&&::Vertx::Util::unknown_type.accept?(elt2)&&::Vertx::Util::unknown_type.accept?(elt3)&&::Vertx::Util::unknown_type.accept?(elt4)&&::Vertx::Util::unknown_type.accept?(elt5)&&!block_given?&&elt6==nilreturn::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::Tuple.java_method(:of,[Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class]).call(::Vertx::Util::Utils.to_object(elt1),::Vertx::Util::Utils.to_object(elt2),::Vertx::Util::Utils.to_object(elt3),::Vertx::Util::Utils.to_object(elt4),::Vertx::Util::Utils.to_object(elt5)),::ReactivePgClient::Tuple)elsif::Vertx::Util::unknown_type.accept?(elt1)&&::Vertx::Util::unknown_type.accept?(elt2)&&::Vertx::Util::unknown_type.accept?(elt3)&&::Vertx::Util::unknown_type.accept?(elt4)&&::Vertx::Util::unknown_type.accept?(elt5)&&::Vertx::Util::unknown_type.accept?(elt6)&&!block_given?return::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::Tuple.java_method(:of,[Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class,Java::java.lang.Object.java_class]).call(::Vertx::Util::Utils.to_object(elt1),::Vertx::Util::Utils.to_object(elt2),::Vertx::Util::Utils.to_object(elt3),::Vertx::Util::Utils.to_object(elt4),::Vertx::Util::Utils.to_object(elt5),::Vertx::Util::Utils.to_object(elt6)),::ReactivePgClient::Tuple)endraiseArgumentError,"Invalid arguments when calling of(#{elt1},#{elt2},#{elt3},#{elt4},#{elt5},#{elt6})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 35defself.tupleif!block_given?return::Vertx::Util::Utils.safe_create(Java::IoReactiversePgclient::Tuple.java_method(:tuple,[]).call(),::ReactivePgClient::Tuple)endraiseArgumentError,"Invalid arguments when calling tuple()"end
+ (Object) unwrap(obj)
25
26
27
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 25def@@j_api_type.unwrap(obj)obj.j_delend
+ (Object) wrap(obj)
22
23
24
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 22def@@j_api_type.wrap(obj)Tuple.new(obj)end
Instance Method Details
- (self) add_boolean(value = nil)
Add a boolean value at the end of the tuple.
Parameters:
value(true, false)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
230
231
232
233
234
235
236
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 230defadd_boolean(value=nil)if(value.class==TrueClass||value.class==FalseClass)&&!block_given?@j_del.java_method(:addBoolean,[Java::JavaLang::Boolean.java_class]).call(value)returnselfendraiseArgumentError,"Invalid arguments when calling add_boolean(#{value})"end
- (self) add_box(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
360
361
362
363
364
365
366
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 360defadd_box(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addBox,[Java::IoReactiversePgclientData::Box.java_class]).call(Java::IoReactiversePgclientData::Box.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_box(#{value})"end
- (self) add_buffer(value = nil)
Add a buffer value at the end of the tuple.
Parameters:
value(::Vertx::Buffer)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
320
321
322
323
324
325
326
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 320defadd_buffer(value=nil)ifvalue.class.method_defined?(:j_del)&&!block_given?@j_del.java_method(:addBuffer,[Java::IoVertxCoreBuffer::Buffer.java_class]).call(value.j_del)returnselfendraiseArgumentError,"Invalid arguments when calling add_buffer(#{value})"end
- (self) add_circle(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
390
391
392
393
394
395
396
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 390defadd_circle(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addCircle,[Java::IoReactiversePgclientData::Circle.java_class]).call(Java::IoReactiversePgclientData::Circle.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_circle(#{value})"end
- (self) add_double(value = nil)
Add a double value at the end of the tuple.
Parameters:
value(Float)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
290
291
292
293
294
295
296
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 290defadd_double(value=nil)ifvalue.class==Float&&!block_given?@j_del.java_method(:addDouble,[Java::JavaLang::Double.java_class]).call(::Vertx::Util::Utils.to_double(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_double(#{value})"end
- (self) add_float(value = nil)
Add a float value at the end of the tuple.
Parameters:
value(Float)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
280
281
282
283
284
285
286
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 280defadd_float(value=nil)ifvalue.class==Float&&!block_given?@j_del.java_method(:addFloat,[Java::JavaLang::Float.java_class]).call(::Vertx::Util::Utils.to_float(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_float(#{value})"end
- (self) add_integer(value = nil)
Add an integer value at the end of the tuple.
Parameters:
value(Fixnum)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
260
261
262
263
264
265
266
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 260defadd_integer(value=nil)ifvalue.class==Fixnum&&!block_given?@j_del.java_method(:addInteger,[Java::JavaLang::Integer.java_class]).call(::Vertx::Util::Utils.to_integer(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_integer(#{value})"end
- (self) add_interval(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
400
401
402
403
404
405
406
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 400defadd_interval(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addInterval,[Java::IoReactiversePgclientData::Interval.java_class]).call(Java::IoReactiversePgclientData::Interval.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_interval(#{value})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 310defadd_json(value=nil)ifvalue.class.method_defined?(:j_del)&&!block_given?@j_del.java_method(:addJson,[Java::IoReactiversePgclientData::Json.java_class]).call(value.j_del)returnselfendraiseArgumentError,"Invalid arguments when calling add_json(#{value})"end
- (self) add_line(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
340
341
342
343
344
345
346
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 340defadd_line(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addLine,[Java::IoReactiversePgclientData::Line.java_class]).call(Java::IoReactiversePgclientData::Line.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_line(#{value})"end
- (self) add_line_segment(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
350
351
352
353
354
355
356
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 350defadd_line_segment(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addLineSegment,[Java::IoReactiversePgclientData::LineSegment.java_class]).call(Java::IoReactiversePgclientData::LineSegment.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_line_segment(#{value})"end
- (self) add_long(value = nil)
Add a long value at the end of the tuple.
Parameters:
value(Fixnum)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
270
271
272
273
274
275
276
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 270defadd_long(value=nil)ifvalue.class==Fixnum&&!block_given?@j_del.java_method(:addLong,[Java::JavaLang::Long.java_class]).call(value)returnselfendraiseArgumentError,"Invalid arguments when calling add_long(#{value})"end
- (self) add_path(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
370
371
372
373
374
375
376
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 370defadd_path(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addPath,[Java::IoReactiversePgclientData::Path.java_class]).call(Java::IoReactiversePgclientData::Path.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_path(#{value})"end
- (self) add_point(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
330
331
332
333
334
335
336
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 330defadd_point(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addPoint,[Java::IoReactiversePgclientData::Point.java_class]).call(Java::IoReactiversePgclientData::Point.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_point(#{value})"end
- (self) add_polygon(value = nil)
Add a value at the end of the tuple.
Parameters:
value(Hash)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
380
381
382
383
384
385
386
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 380defadd_polygon(value=nil)ifvalue.class==Hash&&!block_given?@j_del.java_method(:addPolygon,[Java::IoReactiversePgclientData::Polygon.java_class]).call(Java::IoReactiversePgclientData::Polygon.new(::Vertx::Util::Utils.to_json_object(value)))returnselfendraiseArgumentError,"Invalid arguments when calling add_polygon(#{value})"end
- (self) add_short(value = nil)
Add a short value at the end of the tuple.
Parameters:
value(Fixnum)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
250
251
252
253
254
255
256
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 250defadd_short(value=nil)ifvalue.class==Fixnum&&!block_given?@j_del.java_method(:addShort,[Java::JavaLang::Short.java_class]).call(::Vertx::Util::Utils.to_short(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_short(#{value})"end
- (self) add_string(value = nil)
Add a string value at the end of the tuple.
Parameters:
value(String)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
300
301
302
303
304
305
306
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 300defadd_string(value=nil)ifvalue.class==String&&!block_given?@j_del.java_method(:addString,[Java::java.lang.String.java_class]).call(value)returnselfendraiseArgumentError,"Invalid arguments when calling add_string(#{value})"end
- (self) add_value(value = nil)
Add an object value at the end of the tuple.
Parameters:
value(Object)(defaults to: nil)
—
the value
Returns:
(self)
Raises:
(ArgumentError)
240
241
242
243
244
245
246
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 240defadd_value(value=nil)if::Vertx::Util::unknown_type.accept?(value)&&!block_given?@j_del.java_method(:addValue,[Java::java.lang.Object.java_class]).call(::Vertx::Util::Utils.to_object(value))returnselfendraiseArgumentError,"Invalid arguments when calling add_value(#{value})"end
- (void) clear
This method returns an undefined value.
Raises:
(ArgumentError)
415
416
417
418
419
420
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 415defclearif!block_given?return@j_del.java_method(:clear,[]).call()endraiseArgumentError,"Invalid arguments when calling clear()"end
- (true, false) get_boolean?(pos = nil)
Get a boolean value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(true, false)
—
the value or null
Raises:
(ArgumentError)
68
69
70
71
72
73
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 68defget_boolean?(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getBoolean,[Java::int.java_class]).call(pos)endraiseArgumentError,"Invalid arguments when calling get_boolean?(#{pos})"end
- (Hash) get_box(pos = nil)
Get value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
176
177
178
179
180
181
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 176defget_box(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getBox,[Java::int.java_class]).call(pos)!=nil?JSON.parse(@j_del.java_method(:getBox,[Java::int.java_class]).call(pos).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_box(#{pos})"end
- (::Vertx::Buffer) get_buffer(pos = nil)
Get a buffer value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(::Vertx::Buffer)
—
the value or null
Raises:
(ArgumentError)
221
222
223
224
225
226
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 221defget_buffer(pos=nil)ifpos.class==Fixnum&&!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:getBuffer,[Java::int.java_class]).call(pos),::Vertx::Buffer)endraiseArgumentError,"Invalid arguments when calling get_buffer(#{pos})"end
- (Hash) get_circle(pos = nil)
Get value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
203
204
205
206
207
208
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 203defget_circle(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getCircle,[Java::int.java_class]).call(pos)!=nil?JSON.parse(@j_del.java_method(:getCircle,[Java::int.java_class]).call(pos).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_circle(#{pos})"end
- (Float) get_double(pos = nil)
Get a double value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Float)
—
the value or null
Raises:
(ArgumentError)
122
123
124
125
126
127
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 122defget_double(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getDouble,[Java::int.java_class]).call(pos)endraiseArgumentError,"Invalid arguments when calling get_double(#{pos})"end
- (Float) get_float(pos = nil)
Get a float value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Float)
—
the value or null
Raises:
(ArgumentError)
113
114
115
116
117
118
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 113defget_float(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getFloat,[Java::int.java_class]).call(pos)endraiseArgumentError,"Invalid arguments when calling get_float(#{pos})"end
- (Fixnum) get_integer(pos = nil)
Get an integer value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Fixnum)
—
the value or null
Raises:
(ArgumentError)
95
96
97
98
99
100
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 95defget_integer(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getInteger,[Java::int.java_class]).call(pos)endraiseArgumentError,"Invalid arguments when calling get_integer(#{pos})"end
- (Hash) get_interval(pos = nil)
Get value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
212
213
214
215
216
217
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 212defget_interval(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getInterval,[Java::int.java_class]).call(pos)!=nil?JSON.parse(@j_del.java_method(:getInterval,[Java::int.java_class]).call(pos).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_interval(#{pos})"end
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 140defget_json(pos=nil)ifpos.class==Fixnum&&!block_given?return::Vertx::Util::Utils.safe_create(@j_del.java_method(:getJson,[Java::int.java_class]).call(pos),::ReactivePgClient::Json)endraiseArgumentError,"Invalid arguments when calling get_json(#{pos})"end
- (Hash) get_line(pos = nil)
Get value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
158
159
160
161
162
163
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 158defget_line(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getLine,[Java::int.java_class]).call(pos)!=nil?JSON.parse(@j_del.java_method(:getLine,[Java::int.java_class]).call(pos).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_line(#{pos})"end
- (Hash) get_line_segment(pos = nil)
Get value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
167
168
169
170
171
172
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 167defget_line_segment(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getLineSegment,[Java::int.java_class]).call(pos)!=nil?JSON.parse(@j_del.java_method(:getLineSegment,[Java::int.java_class]).call(pos).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_line_segment(#{pos})"end
- (Fixnum) get_long(pos = nil)
Get a long value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Fixnum)
—
the value or null
Raises:
(ArgumentError)
104
105
106
107
108
109
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 104defget_long(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getLong,[Java::int.java_class]).call(pos)endraiseArgumentError,"Invalid arguments when calling get_long(#{pos})"end
- (Hash) get_path(pos = nil)
Get value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
185
186
187
188
189
190
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 185defget_path(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getPath,[Java::int.java_class]).call(pos)!=nil?JSON.parse(@j_del.java_method(:getPath,[Java::int.java_class]).call(pos).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_path(#{pos})"end
- (Hash) get_point(pos = nil)
Get value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
149
150
151
152
153
154
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 149defget_point(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getPoint,[Java::int.java_class]).call(pos)!=nil?JSON.parse(@j_del.java_method(:getPoint,[Java::int.java_class]).call(pos).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_point(#{pos})"end
- (Hash) get_polygon(pos = nil)
Get value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Hash)
—
the value or null
Raises:
(ArgumentError)
194
195
196
197
198
199
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 194defget_polygon(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getPolygon,[Java::int.java_class]).call(pos)!=nil?JSON.parse(@j_del.java_method(:getPolygon,[Java::int.java_class]).call(pos).toJson.encode):nilendraiseArgumentError,"Invalid arguments when calling get_polygon(#{pos})"end
- (Fixnum) get_short(pos = nil)
Get a short value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Fixnum)
—
the value or null
Raises:
(ArgumentError)
86
87
88
89
90
91
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 86defget_short(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getShort,[Java::int.java_class]).call(pos)endraiseArgumentError,"Invalid arguments when calling get_short(#{pos})"end
- (String) get_string(pos = nil)
Get a string value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(String)
—
the value or null
Raises:
(ArgumentError)
131
132
133
134
135
136
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 131defget_string(pos=nil)ifpos.class==Fixnum&&!block_given?return@j_del.java_method(:getString,[Java::int.java_class]).call(pos)endraiseArgumentError,"Invalid arguments when calling get_string(#{pos})"end
- (Object) get_value(pos = nil)
Get an object value at pos.
Parameters:
pos(Fixnum)(defaults to: nil)
—
the position
Returns:
(Object)
—
the value or null
Raises:
(ArgumentError)
77
78
79
80
81
82
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 77defget_value(pos=nil)ifpos.class==Fixnum&&!block_given?return::Vertx::Util::Utils.from_object(@j_del.java_method(:getValue,[Java::int.java_class]).call(pos))endraiseArgumentError,"Invalid arguments when calling get_value(#{pos})"end
- (Fixnum) size
Returns the tuple size
Returns:
(Fixnum)
—
the tuple size
Raises:
(ArgumentError)
408
409
410
411
412
413
# File '/Users/julien/java/reactive-pg-client/target/classes/reactive-pg-client/tuple.rb', line 408defsizeif!block_given?return@j_del.java_method(:size,[]).call()endraiseArgumentError,"Invalid arguments when calling size()"end
If you are using Vertx 3.5.x you should use instead 0.10.9
Then the code is quite straightforward:
// Pool options
PgPoolOptions options = new PgPoolOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
.setMaxSize(5);
// Create the client pool
PgPool client = PgClient.pool(options);
// A simple query
client.query("SELECT * FROM users WHERE id='julien'", ar -> {
if (ar.succeeded()) {
PgResult<Row> result = ar.result();
System.out.println("Got " + result.size() + " results ");
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
// Now close the pool
client.close();
});
Integration / Usages
vertx-jooq: writing type safe queries and let them run at high speed using jOOQ, vertx and the reactive-pg-client.
Micronaut: supports reactive and non-blocking client to connect to Postgres using reactive-pg-client, allowing to handle many database connections with a single thread.
Out of the box, the test suite runs an embedded Postgres by default.
You can change the version of the embedded Postgres by passing a property embedded.postgres.version like this:
> mvn test -Dembedded.postgres.version=9.6
The following versions of embedded Postgres are supported:
9.6
10.6 (default)
11.1 (not supported on Linux)
Testing with an external database
You can run tests with an external database:
the script docker/postgres/resources/create-postgres.sql creates the test data
the TLSTest expects the database to be configured with SSL with docker/postgres/resources/server.key / docker/postgres/resources/server.cert`
You need to add some properties for testing:
> mvn test -Dconnection.uri=postgres://$username:$password@$host:$port/$database -Dtls.connection.uri=postgres://$username:$password@$host:$port/$database -Dunix.socket.directory=$path
connection.uri(mandatory): configure the client to connect the specified database
tls.connection.uri(mandatory): configure the client to run TLSTest with the specified Postgres with SSL enabled
unix.socket.directory(optional): the single unix socket directory(multiple socket directories are not supported) to test Unix domain socket with a specified database, domain socket tests will be skipped if this property is not specified
(Note: Make sure you can access the unix domain socket with this directory under your host machine)
unix.socket.port(optional): unix socket file is named .s.PGSQL.nnnn and nnnn is the server’s port number,
this property is mostly used when you test with Docker, when you publish your Postgres container port other than 5432 in your host but Postgres may actually listen on a different port in the container,
you will then need this property to help you connect the Postgres with Unix domain socket
Testing with Docker
Run the Postgres containers with docker-compose:
> cd docker/postgres
> docker-compose up --build -V
Run tests:
> mvn test -Dconnection.uri=postgres://$username:$password@$host:$port/$database -Dtls.connection.uri=postgres://$username:$password@$host:$port/$database -Dunix.socket.directory=$path -Dunix.socket.port=$port
Documentation
The online and published documentation is in /docs and is served by GitHub pages with Jekyll.
You can find the actual guide source in [src/main/docs/index.md](src/main/docs/index.md). At compilation time, this
source generates the jekyll/guide/java/index.md.
The current documentation is in /jekyll and can be preview using Docker and your browser
generate the documentation
mvn compile to generate jekyll/guide/java/index.md
mvn site to generate the javadoc in jekyll/apidocs
If you are using Vertx 3.5.x you should use instead 0.10.9
Then the code is quite straightforward:
// Pool options
PgPoolOptions options = new PgPoolOptions()
.setPort(5432)
.setHost("the-host")
.setDatabase("the-db")
.setUser("user")
.setPassword("secret")
.setMaxSize(5);
// Create the client pool
PgPool client = PgClient.pool(options);
// A simple query
client.query("SELECT * FROM users WHERE id='julien'", ar -> {
if (ar.succeeded()) {
PgResult<Row> result = ar.result();
System.out.println("Got " + result.size() + " results ");
} else {
System.out.println("Failure: " + ar.cause().getMessage());
}
// Now close the pool
client.close();
});
Integration / Usages
vertx-jooq: writing type safe queries and let them run at high speed using jOOQ, vertx and the reactive-pg-client.
Micronaut: supports reactive and non-blocking client to connect to Postgres using reactive-pg-client, allowing to handle many database connections with a single thread.
Out of the box, the test suite runs an embedded Postgres by default.
You can change the version of the embedded Postgres by passing a property embedded.postgres.version like this:
> mvn test -Dembedded.postgres.version=9.6
The following versions of embedded Postgres are supported:
9.6
10.6 (default)
11.1 (not supported on Linux)
Testing with an external database
You can run tests with an external database:
the script docker/postgres/resources/create-postgres.sql creates the test data
the TLSTest expects the database to be configured with SSL with docker/postgres/resources/server.key / docker/postgres/resources/server.cert`
You need to add some properties for testing:
> mvn test -Dconnection.uri=postgres://$username:$password@$host:$port/$database -Dtls.connection.uri=postgres://$username:$password@$host:$port/$database -Dunix.socket.directory=$path
connection.uri(mandatory): configure the client to connect the specified database
tls.connection.uri(mandatory): configure the client to run TLSTest with the specified Postgres with SSL enabled
unix.socket.directory(optional): the single unix socket directory(multiple socket directories are not supported) to test Unix domain socket with a specified database, domain socket tests will be skipped if this property is not specified
(Note: Make sure you can access the unix domain socket with this directory under your host machine)
unix.socket.port(optional): unix socket file is named .s.PGSQL.nnnn and nnnn is the server’s port number,
this property is mostly used when you test with Docker, when you publish your Postgres container port other than 5432 in your host but Postgres may actually listen on a different port in the container,
you will then need this property to help you connect the Postgres with Unix domain socket
Testing with Docker
Run the Postgres containers with docker-compose:
> cd docker/postgres
> docker-compose up --build -V
Run tests:
> mvn test -Dconnection.uri=postgres://$username:$password@$host:$port/$database -Dtls.connection.uri=postgres://$username:$password@$host:$port/$database -Dunix.socket.directory=$path -Dunix.socket.port=$port
Documentation
The online and published documentation is in /docs and is served by GitHub pages with Jekyll.
You can find the actual guide source in [src/main/docs/index.md](src/main/docs/index.md). At compilation time, this
source generates the jekyll/guide/java/index.md.
The current documentation is in /jekyll and can be preview using Docker and your browser
generate the documentation
mvn compile to generate jekyll/guide/java/index.md
mvn site to generate the javadoc in jekyll/apidocs
