MSSQL command messages should be named MSSQLCommandMessage instead of MSSQLCommandCodec for more clarity.

vietj · vietj · commit 7e93c76e8fa6 · 2025-07-02T10:18:16.000+02:00
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLSocketConnection.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLSocketConnection.java
@@ -27,8 +27,8 @@
 import io.vertx.core.spi.metrics.ClientMetrics;
 import io.vertx.mssqlclient.MSSQLConnectOptions;
 import io.vertx.mssqlclient.MSSQLInfo;
-import io.vertx.mssqlclient.impl.codec.ExtendedQueryCommandBaseCodec;
-import io.vertx.mssqlclient.impl.codec.MSSQLCommandCodec;
+import io.vertx.mssqlclient.impl.codec.ExtendedQueryMSSQLCommandBaseMessage;
+import io.vertx.mssqlclient.impl.codec.MSSQLCommandMessage;
 import io.vertx.mssqlclient.impl.codec.MSSQLPreparedStatement;
 import io.vertx.mssqlclient.impl.codec.TdsLoginSentCompletionHandler;
 import io.vertx.mssqlclient.impl.codec.TdsMessageCodec;
@@ -156,12 +156,12 @@ public void init() {
 
   @Override
   protected CommandMessage<?, ?> toMessage(ExtendedQueryCommand<?> command, PreparedStatement preparedStatement) {
-    return ExtendedQueryCommandBaseCodec.create(command, (MSSQLPreparedStatement)preparedStatement);
+    return ExtendedQueryMSSQLCommandBaseMessage.create(command, (MSSQLPreparedStatement)preparedStatement);
   }
 
   @Override
   protected CommandMessage<?, ?> toMessage(CommandBase<?> command) {
-    return MSSQLCommandCodec.wrap(command);
+    return MSSQLCommandMessage.wrap(command);
   }
 
   @Override
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/CloseConnectionMSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/CloseConnectionMSSQLCommandMessage.java
@@ -13,8 +13,8 @@
 
 import io.vertx.sqlclient.spi.protocol.CloseConnectionCommand;
 
-class CloseConnectionCommandCodec extends MSSQLCommandCodec<Void, CloseConnectionCommand> {
-  CloseConnectionCommandCodec(CloseConnectionCommand cmd) {
+class CloseConnectionMSSQLCommandMessage extends MSSQLCommandMessage<Void, CloseConnectionCommand> {
+  CloseConnectionMSSQLCommandMessage(CloseConnectionCommand cmd) {
     super(cmd);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/CloseCursorMSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/CloseCursorMSSQLCommandMessage.java
@@ -18,12 +18,12 @@
 import static io.vertx.mssqlclient.impl.codec.DataType.INTN;
 import static io.vertx.mssqlclient.impl.codec.MessageType.RPC;
 
-public class CloseCursorCommandCodec extends MSSQLCommandCodec<Void, CloseCursorCommand> {
+public class CloseCursorMSSQLCommandMessage extends MSSQLCommandMessage<Void, CloseCursorCommand> {
 
   private CursorData cursorData;
   private boolean cursorClosed;
 
-  public CloseCursorCommandCodec(CloseCursorCommand cmd) {
+  public CloseCursorMSSQLCommandMessage(CloseCursorCommand cmd) {
     super(cmd);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/CloseStatementMSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/CloseStatementMSSQLCommandMessage.java
@@ -18,9 +18,9 @@
 import static io.vertx.mssqlclient.impl.codec.DataType.INTN;
 import static io.vertx.mssqlclient.impl.codec.MessageType.RPC;
 
-class CloseStatementCommandCodec extends MSSQLCommandCodec<Void, CloseStatementCommand> {
+class CloseStatementMSSQLCommandMessage extends MSSQLCommandMessage<Void, CloseStatementCommand> {
 
-  CloseStatementCommandCodec(CloseStatementCommand cmd) {
+  CloseStatementMSSQLCommandMessage(CloseStatementCommand cmd) {
     super(cmd);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/ExtendedBatchQueryMSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/ExtendedBatchQueryMSSQLCommandMessage.java
@@ -18,14 +18,14 @@
 
 import java.util.List;
 
-class ExtendedBatchQueryCommandCodec<T> extends ExtendedQueryCommandBaseCodec<T> {
+class ExtendedBatchQueryMSSQLCommandMessage<T> extends ExtendedQueryMSSQLCommandBaseMessage<T> {
 
   private final List<TupleBase> paramsList;
 
   private int paramsIdx;
   private int messageDecoded;
 
-  ExtendedBatchQueryCommandCodec(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {
+  ExtendedBatchQueryMSSQLCommandMessage(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {
     super(cmd, ps);
     paramsList = cmd.paramsList();
   }
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/ExtendedCursorQueryMSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/ExtendedCursorQueryMSSQLCommandMessage.java
@@ -19,11 +19,11 @@
 import static io.vertx.mssqlclient.impl.codec.DataType.NVARCHAR;
 import static io.vertx.mssqlclient.impl.codec.MessageType.RPC;
 
-class ExtendedCursorQueryCommandCodec<T> extends ExtendedQueryCommandBaseCodec<T> {
+class ExtendedCursorQueryMSSQLCommandMessage<T> extends ExtendedQueryMSSQLCommandBaseMessage<T> {
 
   private CursorData cursorData;
 
-  ExtendedCursorQueryCommandCodec(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {
+  ExtendedCursorQueryMSSQLCommandMessage(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {
     super(cmd, ps);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/ExtendedQueryMSSQLCommandBaseMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/ExtendedQueryMSSQLCommandBaseMessage.java
@@ -19,22 +19,22 @@
 import static io.vertx.mssqlclient.impl.codec.DataType.*;
 import static io.vertx.mssqlclient.impl.codec.MessageType.RPC;
 
-public abstract class ExtendedQueryCommandBaseCodec<T> extends QueryCommandBaseCodec<T, ExtendedQueryCommand<T>> {
+public abstract class ExtendedQueryMSSQLCommandBaseMessage<T> extends QueryMSSQLCommandBaseMessage<T, ExtendedQueryCommand<T>> {
 
   final MSSQLPreparedStatement ps;
 
-  public ExtendedQueryCommandBaseCodec(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {
+  public ExtendedQueryMSSQLCommandBaseMessage(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {
     super(cmd);
     this.ps = ps;
   }
 
-  public static <U> MSSQLCommandCodec<?, ?> create(ExtendedQueryCommand<U> queryCmd, MSSQLPreparedStatement ps) {
+  public static <U> MSSQLCommandMessage<?, ?> create(ExtendedQueryCommand<U> queryCmd, MSSQLPreparedStatement ps) {
     if (queryCmd.isBatch()) {
-      return new ExtendedBatchQueryCommandCodec<>(queryCmd, ps);
+      return new ExtendedBatchQueryMSSQLCommandMessage<>(queryCmd, ps);
     } else if (queryCmd.cursorId() != null) {
-      return new ExtendedCursorQueryCommandCodec<>(queryCmd, ps);
+      return new ExtendedCursorQueryMSSQLCommandMessage<>(queryCmd, ps);
     } else {
-      return new ExtendedQueryCommandCodec<>(queryCmd, ps);
+      return new ExtendedQueryMSSQLCommandMessage<>(queryCmd, ps);
     }
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/ExtendedQueryMSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/ExtendedQueryMSSQLCommandMessage.java
@@ -14,9 +14,9 @@
 import io.vertx.sqlclient.internal.TupleBase;
 import io.vertx.sqlclient.spi.protocol.ExtendedQueryCommand;
 
-class ExtendedQueryCommandCodec<T> extends ExtendedQueryCommandBaseCodec<T> {
+class ExtendedQueryMSSQLCommandMessage<T> extends ExtendedQueryMSSQLCommandBaseMessage<T> {
 
-  ExtendedQueryCommandCodec(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {
+  ExtendedQueryMSSQLCommandMessage(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {
     super(cmd, ps);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/InitMSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/InitMSSQLCommandMessage.java
@@ -27,11 +27,11 @@
 import static java.nio.charset.StandardCharsets.UTF_16LE;
 import static java.util.Locale.ENGLISH;
 
-class InitCommandCodec extends MSSQLCommandCodec<Connection, InitCommand> {
+class InitMSSQLCommandMessage extends MSSQLCommandMessage<Connection, InitCommand> {
 
   static final Object LOGIN_SENT = new Object();
 
-  InitCommandCodec(InitCommand cmd) {
+  InitMSSQLCommandMessage(InitCommand cmd) {
     super(cmd);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/MSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/MSSQLCommandMessage.java
@@ -32,32 +32,32 @@
 import static io.vertx.mssqlclient.impl.utils.ByteBufUtils.readUnsignedByteLengthString;
 import static io.vertx.mssqlclient.impl.utils.ByteBufUtils.readUnsignedShortLengthString;
 
-public abstract class MSSQLCommandCodec<R, C extends CommandBase<R>> extends CommandMessage<R, C> {
+public abstract class MSSQLCommandMessage<R, C extends CommandBase<R>> extends CommandMessage<R, C> {
 
   public TdsMessageCodec tdsMessageCodec;
 
   public MSSQLException failure;
   public R result;
 
-  MSSQLCommandCodec(C cmd) {
+  MSSQLCommandMessage(C cmd) {
     super(cmd);
   }
 
-  public static MSSQLCommandCodec<?, ?> wrap(CommandBase<?> cmd) {
+  public static MSSQLCommandMessage<?, ?> wrap(CommandBase<?> cmd) {
     if (cmd instanceof PreLoginCommand) {
-      return new PreLoginCommandCodec((PreLoginCommand) cmd);
+      return new PreLoginMSSQLCommandMessage((PreLoginCommand) cmd);
     } else if (cmd instanceof InitCommand) {
-      return new InitCommandCodec((InitCommand) cmd);
+      return new InitMSSQLCommandMessage((InitCommand) cmd);
     } else if (cmd instanceof SimpleQueryCommand) {
-      return new SQLBatchCommandCodec<>((SimpleQueryCommand<?>) cmd);
+      return new SQLBatchMSSQLCommandMessage<>((SimpleQueryCommand<?>) cmd);
     } else if (cmd instanceof PrepareStatementCommand) {
-      return new PrepareStatementCodec((PrepareStatementCommand) cmd);
+      return new PrepareStatementMSSQLMessage((PrepareStatementCommand) cmd);
     } else if (cmd instanceof CloseStatementCommand) {
-      return new CloseStatementCommandCodec((CloseStatementCommand) cmd);
+      return new CloseStatementMSSQLCommandMessage((CloseStatementCommand) cmd);
     } else if (cmd == CloseConnectionCommand.INSTANCE) {
-      return new CloseConnectionCommandCodec((CloseConnectionCommand) cmd);
+      return new CloseConnectionMSSQLCommandMessage((CloseConnectionCommand) cmd);
     } else if (cmd instanceof CloseCursorCommand) {
-      return new CloseCursorCommandCodec((CloseCursorCommand) cmd);
+      return new CloseCursorMSSQLCommandMessage((CloseCursorCommand) cmd);
     } else {
       throw new UnsupportedOperationException();
     }
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/PreLoginMSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/PreLoginMSSQLCommandMessage.java
@@ -21,13 +21,13 @@
 import static io.vertx.mssqlclient.impl.codec.EncryptionLevel.ENCRYPT_ON;
 import static io.vertx.mssqlclient.impl.codec.MessageType.PRE_LOGIN;
 
-class PreLoginCommandCodec extends MSSQLCommandCodec<PreLoginResponse, PreLoginCommand> {
+class PreLoginMSSQLCommandMessage extends MSSQLCommandMessage<PreLoginResponse, PreLoginCommand> {
 
   private static final int VERSION = 0x00;
   private static final int ENCRYPTION = 0x01;
   private static final int TERMINATOR = 0xFF;
 
-  PreLoginCommandCodec(PreLoginCommand cmd) {
+  PreLoginMSSQLCommandMessage(PreLoginCommand cmd) {
     super(cmd);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/PrepareStatementMSSQLMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/PrepareStatementMSSQLMessage.java
@@ -15,8 +15,8 @@
 import io.vertx.sqlclient.codec.CommandResponse;
 import io.vertx.sqlclient.spi.protocol.PrepareStatementCommand;
 
-class PrepareStatementCodec extends MSSQLCommandCodec<PreparedStatement, PrepareStatementCommand> {
-  PrepareStatementCodec(PrepareStatementCommand cmd) {
+class PrepareStatementMSSQLMessage extends MSSQLCommandMessage<PreparedStatement, PrepareStatementCommand> {
+  PrepareStatementMSSQLMessage(PrepareStatementCommand cmd) {
     super(cmd);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/QueryMSSQLCommandBaseMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/QueryMSSQLCommandBaseMessage.java
@@ -18,12 +18,12 @@
 
 import java.util.stream.Collector;
 
-abstract class QueryCommandBaseCodec<T, C extends QueryCommandBase<T>> extends MSSQLCommandCodec<Boolean, C> {
+abstract class QueryMSSQLCommandBaseMessage<T, C extends QueryCommandBase<T>> extends MSSQLCommandMessage<Boolean, C> {
 
   protected int rowCount;
   protected RowResultDecoder<?, T> rowResultDecoder;
 
-  QueryCommandBaseCodec(C cmd) {
+  QueryMSSQLCommandBaseMessage(C cmd) {
     super(cmd);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/SQLBatchMSSQLCommandMessage.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/SQLBatchMSSQLCommandMessage.java
@@ -18,8 +18,8 @@
 
 import static io.vertx.mssqlclient.impl.codec.MessageType.SQL_BATCH;
 
-class SQLBatchCommandCodec<T> extends QueryCommandBaseCodec<T, SimpleQueryCommand<T>> {
-  SQLBatchCommandCodec(SimpleQueryCommand<T> cmd) {
+class SQLBatchMSSQLCommandMessage<T> extends QueryMSSQLCommandBaseMessage<T, SimpleQueryCommand<T>> {
+  SQLBatchMSSQLCommandMessage(SimpleQueryCommand<T> cmd) {
     super(cmd);
   }
 
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/TdsLoginSentCompletionHandler.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/TdsLoginSentCompletionHandler.java
@@ -21,7 +21,7 @@
 /**
  * A channel handler which listens to the {@code LOGIN_SENT} user event.
  * <p>
- * This event is triggered by the {@link InitCommandCodec} after the login packet has been sent to the server.
+ * This event is triggered by the {@link InitMSSQLCommandMessage} after the login packet has been sent to the server.
  * This handler removes the {@link SslHandler} from the pipeline if the client and the server agreed to encrypt the login packet only.
  * In this case, further traffic (including the login response) will be unencrypted.
  */
@@ -44,7 +44,7 @@ public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
 
   @Override
   public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
-    if (evt == InitCommandCodec.LOGIN_SENT) {
+    if (evt == InitMSSQLCommandMessage.LOGIN_SENT) {
       pipeline.remove(this);
       if (encryptionLevel == ENCRYPT_OFF) {
         pipeline.remove(sslHandler);
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/TdsMessageCodec.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/TdsMessageCodec.java
@@ -14,7 +14,6 @@
 import io.netty.buffer.ByteBufAllocator;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.CombinedChannelDuplexHandler;
-import io.vertx.core.Completable;
 import io.vertx.sqlclient.ClosedConnectionException;
 
 import java.util.ArrayDeque;
@@ -24,7 +23,7 @@
 
 public class TdsMessageCodec extends CombinedChannelDuplexHandler<TdsMessageDecoder, TdsMessageEncoder> {
 
-  private final ArrayDeque<MSSQLCommandCodec<?, ?>> inflight = new ArrayDeque<>();
+  private final ArrayDeque<MSSQLCommandMessage<?, ?>> inflight = new ArrayDeque<>();
   private final TdsMessageEncoder encoder;
   private final TdsMessageDecoder decoder;
 
@@ -56,15 +55,15 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws E
   private void fail(Throwable cause) {
     if (failure == null) {
       failure = cause;
-      for (Iterator<MSSQLCommandCodec<?, ?>> it = inflight.iterator(); it.hasNext(); ) {
-        MSSQLCommandCodec<?, ?> codec = it.next();
+      for (Iterator<MSSQLCommandMessage<?, ?>> it = inflight.iterator(); it.hasNext(); ) {
+        MSSQLCommandMessage<?, ?> codec = it.next();
         it.remove();
         fail(codec, cause);
       }
     }
   }
 
-  private void fail(MSSQLCommandCodec<?, ?> codec, Throwable cause) {
+  private void fail(MSSQLCommandMessage<?, ?> codec, Throwable cause) {
     codec.fail(cause);
   }
 
@@ -98,15 +97,15 @@ void setTransactionDescriptor(long transactionDescriptor) {
     this.transactionDescriptor = transactionDescriptor;
   }
 
-  MSSQLCommandCodec<?, ?> peek() {
+  MSSQLCommandMessage<?, ?> peek() {
     return inflight.peek();
   }
 
-  MSSQLCommandCodec<?, ?> poll() {
+  MSSQLCommandMessage<?, ?> poll() {
     return inflight.poll();
   }
 
-  boolean add(MSSQLCommandCodec<?, ?> codec) {
+  boolean add(MSSQLCommandMessage<?, ?> codec) {
     if (failure == null) {
       inflight.add(codec);
       return true;
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/TdsMessageDecoder.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/TdsMessageDecoder.java
@@ -54,7 +54,7 @@ public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
   }
 
   void fireCommandResponse(CommandResponse<?> commandResponse) {
-    MSSQLCommandCodec<?, ?> c = tdsMessageCodec.poll();
+    MSSQLCommandMessage<?, ?> c = tdsMessageCodec.poll();
     commandResponse.handler = (Completable) c.handler;
     chctx.fireChannelRead(commandResponse);
   }
@@ -68,7 +68,7 @@ private void releaseMessage() {
 
   private void decodeMessage() {
     try {
-      MSSQLCommandCodec<?, ?> commandCodec = tdsMessageCodec.peek();
+      MSSQLCommandMessage<?, ?> commandCodec = tdsMessageCodec.peek();
       if (commandCodec == null) {
         throw new IllegalStateException("No command codec for message of type [" + message.type() + "]");
       }
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/TdsMessageEncoder.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/TdsMessageEncoder.java
@@ -40,16 +40,16 @@ public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
 
   @Override
   public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
-    if (msg instanceof MSSQLCommandCodec<?, ?>) {
-      MSSQLCommandCodec<?, ?> cmd = (MSSQLCommandCodec<?, ?>) msg;
+    if (msg instanceof MSSQLCommandMessage<?, ?>) {
+      MSSQLCommandMessage<?, ?> cmd = (MSSQLCommandMessage<?, ?>) msg;
       cmd.tdsMessageCodec = tdsMessageCodec;
       write(cmd);
     } else {
       super.write(ctx, msg, promise);
     }
   }
 
-  void write(MSSQLCommandCodec<?, ?> cmd) {
+  void write(MSSQLCommandMessage<?, ?> cmd) {
     if (tdsMessageCodec.add(cmd)) {
       cmd.encode();
     }

Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@`
`13`	`13`
`14`	`14`	`import io.vertx.sqlclient.spi.protocol.CloseConnectionCommand;`
`15`	`15`
`16`		`-class CloseConnectionCommandCodec extends MSSQLCommandCodec<Void, CloseConnectionCommand> {`
`17`		`- CloseConnectionCommandCodec(CloseConnectionCommand cmd) {`
	`16`	`+class CloseConnectionMSSQLCommandMessage extends MSSQLCommandMessage<Void, CloseConnectionCommand> {`
	`17`	`+ CloseConnectionMSSQLCommandMessage(CloseConnectionCommand cmd) {`
`18`	`18`	`super(cmd);`
`19`	`19`	`}`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -18,9 +18,9 @@`
`18`	`18`	`import static io.vertx.mssqlclient.impl.codec.DataType.INTN;`
`19`	`19`	`import static io.vertx.mssqlclient.impl.codec.MessageType.RPC;`
`20`	`20`
`21`		`-class CloseStatementCommandCodec extends MSSQLCommandCodec<Void, CloseStatementCommand> {`
	`21`	`+class CloseStatementMSSQLCommandMessage extends MSSQLCommandMessage<Void, CloseStatementCommand> {`
`22`	`22`
`23`		`- CloseStatementCommandCodec(CloseStatementCommand cmd) {`
	`23`	`+ CloseStatementMSSQLCommandMessage(CloseStatementCommand cmd) {`
`24`	`24`	`super(cmd);`
`25`	`25`	`}`
`26`	`26`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,9 @@`
`14`	`14`	`import io.vertx.sqlclient.internal.TupleBase;`
`15`	`15`	`import io.vertx.sqlclient.spi.protocol.ExtendedQueryCommand;`
`16`	`16`
`17`		`-class ExtendedQueryCommandCodec<T> extends ExtendedQueryCommandBaseCodec<T> {`
	`17`	`+class ExtendedQueryMSSQLCommandMessage<T> extends ExtendedQueryMSSQLCommandBaseMessage<T> {`
`18`	`18`
`19`		`- ExtendedQueryCommandCodec(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {`
	`19`	`+ ExtendedQueryMSSQLCommandMessage(ExtendedQueryCommand<T> cmd, MSSQLPreparedStatement ps) {`
`20`	`20`	`super(cmd, ps);`
`21`	`21`	`}`
`22`	`22`