This is an automated email from the ASF dual-hosted git repository.
kenhuuu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
The following commit(s) were added to refs/heads/master by this push:
new 4ccb9d1f87 Improve 4-beta3 documentation CTR.
4ccb9d1f87 is described below
commit 4ccb9d1f87bdb19641c923a67912f6671bb12cf8
Author: Ken Hu <[email protected]>
AuthorDate: Fri Jul 17 13:54:49 2026 -0700
Improve 4-beta3 documentation CTR.
Document canonical Gremlin literal syntax
Update maxConnections references
Remove stale driver pool option docs
Document semantics for new primitive types
Document scriptEngines behavior
Document GLV transaction source handles
Clarify managed transaction upgrade docs
Clarify Python driver upgrade docs
Assisted-by: Codex:gpt-5.5
---
docs/src/dev/provider/gremlin-semantics.asciidoc | 16 ++-
docs/src/reference/gremlin-applications.asciidoc | 27 +++++-
docs/src/reference/gremlin-variants.asciidoc | 24 ++++-
docs/src/reference/the-traversal.asciidoc | 44 +++++++++
docs/src/upgrade/release-4.x.x.asciidoc | 108 ++++++++++-----------
.../apache/tinkerpop/gremlin/driver/Client.java | 2 +-
6 files changed, 152 insertions(+), 69 deletions(-)
diff --git a/docs/src/dev/provider/gremlin-semantics.asciidoc
b/docs/src/dev/provider/gremlin-semantics.asciidoc
index b13b13e6dc..5ccfcd9112 100644
--- a/docs/src/dev/provider/gremlin-semantics.asciidoc
+++ b/docs/src/dev/provider/gremlin-semantics.asciidoc
@@ -250,20 +250,30 @@ any non-`null` value.
For Booleans, `TRUE == TRUE`, `FALSE == FALSE`, `TRUE != FALSE`, and `FALSE <
TRUE`.
-===== STRING
+===== STRING / CHAR
-We assume the common lexicographical order over unicode strings. `A` and `B`
are compared lexicographically, and
-`A == B` if `A` and `B` are lexicographically equal.
+We assume the common lexicographical order over unicode strings and
characters. `A` and `B` are compared
+lexicographically, and `A == B` if `A` and `B` are of the same type and
lexicographically equal.
===== UUID
UUID is evaluated based on its String representation. However,
`UUID("b46d37e9-755c-477e-9ab6-44aabea51d50")` and the
String `"b46d37e9-755c-477e-9ab6-44aabea51d50"` are not <<Equality,Equal>> and
not <<Comparability,Comparable>>.
+===== BINARY
+
+Binary values are evaluated based on lexicographical comparison of their byte
sequences, comparing each byte as a
+signed 8-bit value. `A == B` if `A` and `B` have the same bytes in the same
order.
+
===== DATETIME
Dates are evaluated based on the numerical comparison of Unix Epoch time.
+===== DURATION
+
+Durations are evaluated based on the numerical comparison of their total
length. `A == B` if `A` and `B` represent the
+same total length.
+
===== Graph Elements (VERTEX / EDGE / VPROPERTY)
If they are the same type of Element, these are compared by the value of their
`T.id` according to the semantics for
diff --git a/docs/src/reference/gremlin-applications.asciidoc
b/docs/src/reference/gremlin-applications.asciidoc
index 06b6c95011..04e1d43e67 100644
--- a/docs/src/reference/gremlin-applications.asciidoc
+++ b/docs/src/reference/gremlin-applications.asciidoc
@@ -840,8 +840,7 @@ possible to define the language to utilize to process the
request:
[source,text]
curl -X POST -d "{\"gremlin\":\"100-x\", \"language\":\"gremlin-groovy\",
\"parameters\":\"[x:1]\"}" "http://localhost:8182";
-By default this value is set to `gremlin-groovy`. If using a `GET` operation,
this value can be set as a query
-string argument with by setting the `language` key.
+By default this value is set to `gremlin-lang`. The value is set in the
request body with the `language` key.
[[server-configuring]]
=== Configuring
@@ -955,7 +954,7 @@ The following table describes the various YAML
configuration options that Gremli
|metrics.slf4jReporter.intervalMillis |Time in milliseconds between reports of
metrics to SLF4j. |180000
|port |The port to bind the server to. |8182
|resultIterationBatchSize |Defines the size in which the result of a request
is "batched" back to the client. In other words, if set to `1`, then a result
that had ten items in it would get each result sent back individually. If set
to `2` the same ten results would come back in five batches of two each. |64
-|scriptEngines |A `Map` of `ScriptEngine` implementations to expose through
Gremlin Server, where the key is the name given by the `ScriptEngine`
implementation. The key must match the name exactly for the `ScriptEngine` to
be constructed. The value paired with this key is itself a `Map` of
configuration for that `ScriptEngine`. If this value is not set, it will
default to "gremlin-lang". |_gremlin-lang_
+|scriptEngines |A `Map` of `ScriptEngine` configurations keyed by
`ScriptEngine` name. See <<server-scriptengines-behavior>>. |_gremlin-lang_
|scriptEngines.<name>.imports |A comma separated list of classes/packages to
make available to the `ScriptEngine`. |_none_
|scriptEngines.<name>.staticImports |A comma separated list of "static"
imports to make available to the `ScriptEngine`. |_none_
|scriptEngines.<name>.scripts |A comma separated list of script files to
execute on `ScriptEngine` initialization. Deprecated — use `traversalSources`
and `lifecycleHooks` instead.|_none_
@@ -987,6 +986,28 @@ The following table describes the various YAML
configuration options that Gremli
See the <<metrics,Metrics>> section for more information on how to configure
Ganglia and Graphite.
+[[server-scriptengines-behavior]]
+==== scriptEngines Behavior
+
+The `scriptEngines` configuration identifies the `ScriptEngine`
implementations to expose through Gremlin Server.
+The key is the name given by the `ScriptEngine` implementation and must match
that name exactly. The value paired with
+this key is itself a `Map` of configuration for that `ScriptEngine`.
+
+Only `ScriptEngine` implementations listed in the configuration will accept
requests. The `gremlin-lang`
+`ScriptEngine` is always available regardless of configuration.
+
+A request that specifies an unlisted `language` will receive a `400 Bad
Request` response. Enabling `gremlin-groovy` or
+another `ScriptEngine` therefore requires an explicit entry in `scriptEngines`:
+
+[source,yaml]
+----
+scriptEngines: {
+ gremlin-lang: {},
+ gremlin-groovy: {
+ plugins: {
+ org.apache.tinkerpop.gremlin.server.jsr223.GremlinServerGremlinPlugin:
{}}}}
+----
+
==== Serialization
Gremlin Server can accept requests and return results using different
serialization formats. Serializers implement the
diff --git a/docs/src/reference/gremlin-variants.asciidoc
b/docs/src/reference/gremlin-variants.asciidoc
index fa27b616bf..3bc95a6fb7 100644
--- a/docs/src/reference/gremlin-variants.asciidoc
+++ b/docs/src/reference/gremlin-variants.asciidoc
@@ -419,6 +419,9 @@ err = tx.Commit()
if err != nil { log.Fatal(err) }
----
+The transaction-bound source retains its owning transaction. Calling
`gtx.Tx()` returns the same `Transaction`, so
+lifecycle operations can also be performed from the source with calls such as
`gtx.Tx().Commit()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` provides closure
methods that manage the
@@ -724,6 +727,8 @@ therefore cardinality functions that take a value like
`list()`, `set()`, and `s
[[gremlin-go-limitations]]
=== Limitations
+* The Gremlin `Character` type is not supported by Gremlin-Go.
+
* There is no default `set` type in Go. Any set type code from server will be
deserialized into slices with the list
type implementation. To input a set into Gremlin-Go, a custom struct which
implements the `gremlingo.Set` interface
will be serialized as a set. `gremlingo.NewSimpleSet` is a basic
implementation of a set that is provided by Gremlin-Go
@@ -1153,6 +1158,9 @@ try {
Traversals spawned from `gtx` are bound to the transaction. The driver handles
host pinning and transaction ID
propagation automatically.
+The transaction-bound source retains its owning transaction. Calling
`gtx.tx()` returns the same `Transaction`, so
+lifecycle operations can also be performed from the source with calls such as
`gtx.tx().commit()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` also provides
closure methods that manage the
@@ -1640,9 +1648,7 @@ where this occurs:
The latter of the two can be addressed from the driver side in the following
ways:
* Increase the `maxWaitForConnection` allowing the client to wait a bit longer
for a connection to become available.
-* Increase the number of requests allowed per connection by increasing the
`maxSimultaneousUsagePerConnection` and
-`maxInProcessPerConnection` settings.
-* Increase the number of connections available in the connection pool by
increasing the `maxConnectionPoolSize`.
+* Increase the number of connections available in the connection pool by
increasing the `maxConnections`.
The exception and logs (assuming they are enabled) should contain information
about the state of the connection pool
along with its connections which can help shed more light on which of these
scenarios caused the problem. Some examples
@@ -1660,7 +1666,7 @@ _Client is likely issuing more requests than the pool
size can handle_
[source,text]
----
-Timed-out (150 MILLISECONDS) waiting for connection on
Host{address=localhost/127.0.0.1:45940,
hostUri=http://localhost:45940/gremlin}. Potential Cause: Number of active
requests exceeds pool size. Consider increasing the value for
maxConnectionPoolSize.
+Timed-out (150 MILLISECONDS) waiting for connection on
Host{address=localhost/127.0.0.1:45940,
hostUri=http://localhost:45940/gremlin}. Potential Cause: Number of active
requests (1) exceeds pool size (1). Consider increasing the value for
maxConnections.
ConnectionPool (Host{address=localhost/127.0.0.1:45940,
hostUri=http://localhost:45940/gremlin})
Connection Pool Status (size=1 available=1 max=1 toCreate=0 bin=0 waiter=0)
> Connection{channel=5a859d62 isDead=false borrowed=1 pending=1
> markedReplaced=false closing=false created=2022-12-19T21:08:21.569613100Z
> thread=gremlin-driver-conn-scheduler-1}
@@ -2180,6 +2186,9 @@ await gtx.addV("person").property("name",
"josh").iterate();
await tx.commit();
----
+The transaction-bound source retains its owning transaction. Calling
`gtx.tx()` returns the same `Transaction`, so
+lifecycle operations can also be performed from the source with calls such as
`await gtx.tx().commit()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` provides an
`executeInTx` method that manages the
@@ -2501,6 +2510,7 @@ exact type sent to the server — see
<<gremlin-javascript-numeric-types>>.
signed range are unsuffixed (Int), integers beyond that up to
`Number.MAX_SAFE_INTEGER` use the `L` suffix (Long),
non-integer numbers and integers beyond the safe range use the `D` suffix
(Double), and `BigInt` values use the `N`
suffix (BigInteger).
+* Gremlin `Character` and `Duration` values are not supported.
* The `subgraph()`-step returns a detached `Graph` data container exposing
`vertices: Map<any, Vertex>` and `edges: Map<any, Edge>`. The result is not a
live `Graph` instance: mutating the
collections has no effect on the source graph, and it cannot be passed to
`traversal().with(...)`. To re-query
@@ -2867,6 +2877,9 @@ await gtx.AddV("person").Property("name",
"josh").Promise(t => t.Iterate());
await tx.CommitAsync();
----
+The transaction-bound source retains its owning transaction. Calling
`gtx.Tx()` returns the same `RemoteTransaction`,
+so lifecycle operations can also be performed from the source with calls such
as `await gtx.Tx().CommitAsync()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` provides closure
methods that manage the
@@ -3577,6 +3590,9 @@ gtx.addV('person').property('name', 'josh').iterate()
tx.commit()
----
+The transaction-bound source retains its owning transaction. Calling
`gtx.tx()` returns the same `Transaction`, so
+lifecycle operations can also be performed from the source with calls such as
`gtx.tx().commit()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` provides an
`execute_in_tx` method that manages the
diff --git a/docs/src/reference/the-traversal.asciidoc
b/docs/src/reference/the-traversal.asciidoc
index a44084506a..5a849914d9 100644
--- a/docs/src/reference/the-traversal.asciidoc
+++ b/docs/src/reference/the-traversal.asciidoc
@@ -153,6 +153,10 @@ GraphTraversalSource gtx2 = tx2.begin();
// g operates outside of both tx1 and tx2
----
+The transaction-bound `GraphTraversalSource` can also act as the transaction
handle. Calling `gtx.tx()` (or the
+language-specific casing equivalent) returns the same `Transaction`, which
allows code that only passes `gtx` through a
+helper to still close the transaction with `gtx.tx().commit()` or
`gtx.tx().rollback()`.
+
In remote cases, `GraphTraversalSource` instances spawned from `begin()` are
safe to use from a single thread. The
default behavior of `close()` on a `Transaction` for remote cases is to
`rollback()`, ensuring partial work is
discarded if the user forgets to commit. Users must call `commit()` explicitly
to persist data.
@@ -6174,6 +6178,46 @@ By default, `GType` enumerations are registered using
their simple class names a
g.V().values('age','name').is(P.typeOf('Integer'))
----
+[[canonical-gremlin-literal-types]]
+=== Canonical Gremlin Literal Types
+
+Canonical Gremlin represents typed values as text so that scripts and GLV
requests can be expressed in the
+`gremlin-lang` language and parsed by the `gremlin-lang` script engine. The
authoritative definition of this syntax is
+the
link:https://github.com/apache/tinkerpop/blob/x.y.z/gremlin-language/src/main/antlr4/Gremlin.g4[Gremlin.g4
ANTLR grammar].
+This section summarizes the commonly used literal forms for convenience when
reading canonical Gremlin or writing direct
+script requests.
+
+[width="100%",cols="2,3,6",options="header"]
+|=========================================================
+|Type |Canonical form |Expected input
+|null |`null` |The literal keyword `null`.
+|Boolean |`true`, `false` |The literal keywords `true` and `false`.
+|String |`"marko"`, `'marko'`, `"M"s` |A single-quoted or double-quoted
string. The optional `s` suffix still produces a `String`.
+|Character |`"M"c`, `'M'c` |A single-quoted or double-quoted value that is one
character.
+|Byte |`1B` |An integer with a `B` suffix and a value within the bounds of
`Byte`.
+|Short |`1S` |An integer with an `S` suffix and a value within the bounds of
`Short`.
+|Integer |`1`, `1I` |An integer within the bounds of `Integer`. The `I` suffix
forces `Integer`.
+|Long |`1L` |An integer with an `L` suffix and a value within the bounds of
`Long`.
+|BigInteger |`1N` |An integer with an `N` suffix.
+|Float |`1.0F` |A floating-point number with an `F` suffix and a value within
the bounds of `Float`.
+|Double |`1.0`, `1.0D` |A floating-point number with an optional `D` suffix.
+|BigDecimal |`1.0M` |A floating-point number with an `M` suffix.
+|DateTime |`DateTime("2018-03-22T00:35:44Z")`, `DateTime()` |An ISO-8601 date
or date-time string. `DateTime()` evaluates to the current time.
+|UUID |`UUID("f47af10b-58cc-4372-a567-0f02b2f3d479")`, `UUID()` |A UUID string
in the textual form written as 8-4-4-4-12 hexadecimal digit groups. `UUID()`
generates a random UUID.
+|Duration |`Duration(3600,0)`, `Duration(30,0,false)` |The first argument is
non-negative seconds. The second is nanoseconds from `0` to `999999999`. The
optional third argument is a boolean sign flag with `false` negating the
duration.
+|Binary |`Binary("AQID")` |A Base64-encoded string.
+|Enum |`T.id`, `Cardinality.single`, `Direction.OUT` |A Gremlin enum token
from `T`, `Cardinality`, `Direction`, `Merge`, `Pick`, `DT`, or `GType`.
+|List |`[1,"two",null]` |A comma-separated sequence of generic literals inside
square brackets.
+|Set |`{1,"two"}` |A comma-separated sequence of generic literals inside
braces.
+|Map |`[:]`, `["name":"marko", "age":29]` |An empty map is `[:]`. A populated
map is a comma-separated sequence of `key:value` entries inside square brackets.
+|Provider Defined Type |`PDT("Point",["x":1,"y":2])`, `PDT("Uint32","42")`
|The first argument is the provider-defined type name. The composite form
expects a map literal with string keys. The primitive form expects an opaque
string value.
+|=========================================================
+
+NOTE: Numeric values may be signed, and integer values may use decimal,
hexadecimal (`0x`), or octal (`0`) notation.
+Underscores may appear between digits. Numeric type suffixes are accepted in
either uppercase or lowercase form, though
+the examples above use uppercase suffixes. Special floating-point values are
expressed as `NaN`, `Infinity`,
+`+Infinity`, or `-Infinity`.
+
[[a-note-on-maps]]
== A Note on Maps
diff --git a/docs/src/upgrade/release-4.x.x.asciidoc
b/docs/src/upgrade/release-4.x.x.asciidoc
index 5221c0a9a0..bd9e9f02b1 100644
--- a/docs/src/upgrade/release-4.x.x.asciidoc
+++ b/docs/src/upgrade/release-4.x.x.asciidoc
@@ -214,33 +214,40 @@ Each GLV provides two entry points:
* **Traversal API**: `g.tx().begin()` returns a transaction-bound
`GraphTraversalSource`
* **Driver API**: `client.transact()` (or `client.Transact()` in .NET) returns
a `Transaction` with `submit()` methods
-See the <<gremlin-drivers-variants,Gremlin Drivers and Variants>> reference
documentation for language-specific
-syntax and examples.
+See the
link:https://tinkerpop.apache.org/docs/4.0.0-beta.3/reference/#gremlin-drivers-variants[Gremlin
Drivers and Variants]
+reference documentation for language-specific syntax and examples.
===== Managed Transaction Blocks
-In addition to the manual `begin()`/`commit()`/`rollback()` lifecycle, every
GLV (including the Java driver and embedded
-Java graphs) now offers closure-based convenience methods directly on
`GraphTraversalSource` (`g`). You hand `g` a
-function that receives the transaction-bound `g` (`gtx`), and the transaction
lifecycle is managed for you: the
-transaction is begun, your function runs, and it is committed on normal
completion or rolled back if your function
-raises. This reduces the common begin/do-work/commit boilerplate and makes it
harder to accidentally run a traversal
-against the non-transactional `g`, since only the transactional source is in
scope inside the closure. The methods are a
-Traversal-API convenience (they live on `g`, not on the `Transaction` returned
by `g.tx()`).
-
-The method naming follows each language's idiom (the value-returning form is
`evaluateInTx` rather than `call`, because
-`call` is already the `call()` service step on `GraphTraversalSource`):
-
-* **Java**: `g.executeInTx(Consumer)` (no return) and
`g.evaluateInTx(Function)` (returns the body's value).
-* **Python**: `g.execute_in_tx(fn)` — a single method that returns whatever
the function returns.
-* **JavaScript**: `await g.executeInTx(fn)` — the callback may be `async`;
resolves to the callback's return value.
-* **.NET**: `g.ExecuteInTxAsync(Func<..,Task>)` and
`g.EvaluateInTxAsync<T>(Func<..,Task<T>>)`, both accepting an optional
`CancellationToken`.
-* **Go**: `g.ExecuteInTx(func(*GraphTraversalSource) error) error` and
`g.EvaluateInTx(func(*GraphTraversalSource) (interface{}, error)) (interface{},
error)`.
-
-The closure runs the transaction exactly once (no automatic retry). If the
function fails, the original error is
-re-raised after rollback; if `commit()` fails, the commit error is raised and
a rollback is still attempted to release
-server-side resources. The manual `begin()`/`commit()`/`rollback()` API
remains available and unchanged for advanced
-use. See the <<gremlin-drivers-variants,Gremlin Drivers and Variants>>
reference documentation for language-specific
-examples.
+Managed transaction blocks provide a shorter way to run a unit of work in a
transaction. The application passes a
+closure to `g`, receives a transaction-bound `gtx`, and the transaction will
be committed when the closure completes
+normally or rolled back when the closure throws.
+
+[source,java]
+----
+// before: manage the transaction lifecycle directly
+Transaction tx = g.tx();
+GraphTraversalSource gtx = tx.begin();
+try {
+ gtx.addV("person").property("name", "alice").iterate();
+ gtx.addV("software").property("name", "graph-app").iterate();
+ tx.commit();
+} catch (RuntimeException ex) {
+ tx.rollback();
+ throw ex;
+}
+
+// now: let the traversal source manage the lifecycle
+g.executeInTx(gtx -> {
+ gtx.addV("person").property("name", "alice").iterate();
+ gtx.addV("software").property("name", "graph-app").iterate();
+});
+----
+
+The same managed transaction pattern is supported in every GLV, with method
names following each language's
+conventions. See the
+link:https://tinkerpop.apache.org/docs/4.0.0-beta.3/reference/#gremlin-drivers-variants[Gremlin
Drivers and Variants]
+reference documentation for language-specific syntax and error-handling
details.
See: link:https://issues.apache.org/jira/browse/TINKERPOP-3253[TINKERPOP-3253]
@@ -527,8 +534,6 @@ A character literal is a single-character string with a `c`
suffix:
g.V().has("initial","M"c)
----
-NOTE: Character is not supported in gremlin-go or gremlin-javascript.
-
===== Duration
A duration literal uses seconds and nanoseconds with an optional sign flag:
@@ -567,48 +572,26 @@ g.V().has("blob",P.eq(Binary("AQID")))
See: link:https://issues.apache.org/jira/browse/TINKERPOP-3153[TINKERPOP-3153]
-==== Python Driver Simplification — Removed GraphSON, Abstract Base Classes,
and Protocol Layer
-
-The `AbstractBaseTransport`, `AbstractBaseProtocol`, and
`GremlinServerHTTPProtocol` classes have been removed from
-`gremlin-python`. The protocol layer's request-building logic (serialization,
headers, interceptors, auth) has been
-merged directly into `Connection`. The driver now uses `AiohttpHTTPTransport`
directly without an abstract transport
-interface.
+==== Python Driver Simplification
-`GremlinServerError` has moved from `gremlin_python.driver.protocol` to
`gremlin_python.driver.connection`:
-
-The `GraphSONSerializersV4` class and the
`gremlin_python.structure.io.graphsonV4` module have been removed.
-GraphBinary is the only supported wire format for the Python driver in
TinkerPop 4. Code that constructed
-`GraphSONSerializersV4()` or imported from
`gremlin_python.structure.io.graphsonV4` must switch to
-`GraphBinarySerializersV4` (the default `response_serializer`):
-
-[source,python]
-----
-# Before
-from gremlin_python.driver.protocol import GremlinServerError
-
-# After
-from gremlin_python.driver.connection import GremlinServerError
-----
-
-The `protocol_factory` and `transport_factory` parameters have been removed
from `Client`,
-`DriverRemoteConnection`, and `Connection`. Users who were passing a custom
`protocol_factory` should use the
-`response_serializer`, `auth`, and `interceptors` parameters directly instead.
These cover all functionality that
-`GremlinServerHTTPProtocol` previously provided.
-
-Transport options like SSL and timeouts are now passed as keyword arguments
directly:
+Gremlin for Python has been heavily refactored for this release, simplifying
driver usage and removing unnecessary
+infrastructure. Key areas for change to consider when upgrading include
removal of the old mechanism used to configure
+a custom `transport_factory`, which was commonly used to pass SSL and timeout
options into the underlying transport.
+Those settings now pass directly to `Client` or `DriverRemoteConnection`:
[source,python]
----
# Before
from gremlin_python.driver.aiohttp.transport import AiohttpHTTPTransport
+
Client(url, 'g', transport_factory=lambda:
AiohttpHTTPTransport(ssl_options=ctx, read_timeout=30))
# After
Client(url, 'g', ssl=ctx, read_timeout=30)
----
-The `Connection` constructor signature has changed. The `protocol` and
`transport_factory` positional arguments have
-been removed. Transport kwargs are forwarded to `AiohttpHTTPTransport`
internally:
+The lower-level `Connection` API follows the same simplification. The old
protocol and transport factory arguments have
+been removed, and serializer, authentication, interceptor, and transport
settings are configured directly:
[source,python]
----
@@ -621,9 +604,18 @@ Connection(url, traversal_source, executor, pool,
auth=None, interceptors=None, **transport_kwargs)
----
-Custom transport implementations are no longer supported. The driver uses
`AiohttpHTTPTransport` directly.
+`GremlinServerError` now imports from `gremlin_python.driver.connection`:
+
+[source,python]
+----
+# Before
+from gremlin_python.driver.protocol import GremlinServerError
+
+# After
+from gremlin_python.driver.connection import GremlinServerError
+----
-See:
link:https://tinkerpop.apache.org/docs/4.0.0/reference/#gremlin-python[Gremlin-Python]
+See:
link:https://tinkerpop.apache.org/docs/4.0.0-beta.3/reference/#gremlin-python[Gremlin-Python]
==== Removal of sparql-gremlin
diff --git
a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/Client.java
b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/Client.java
index 2348884b60..adb93f6335 100644
---
a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/Client.java
+++
b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/Client.java
@@ -58,7 +58,7 @@ public abstract class Client implements RequestSubmitter,
RequestSubmitterAsync
private static final Logger logger = LoggerFactory.getLogger(Client.class);
public static final String TOO_MANY_IN_FLIGHT_REQUESTS = "Number of active
requests (%s) exceeds pool size (%s). " +
- "Consider increasing the value for maxConnectionPoolSize.";
+ "Consider increasing the value for maxConnections.";
protected final Cluster cluster;
protected volatile boolean initialized;
