001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.activemq.store.jdbc; 018 019 /** 020 * @version $Revision: 1.4 $ 021 * 022 * @org.apache.xbean.XBean element="statements" 023 * 024 */ 025 public class Statements { 026 027 protected String messageTableName = "ACTIVEMQ_MSGS"; 028 protected String durableSubAcksTableName = "ACTIVEMQ_ACKS"; 029 protected String lockTableName = "ACTIVEMQ_LOCK"; 030 protected String binaryDataType = "BLOB"; 031 protected String containerNameDataType = "VARCHAR(250)"; 032 protected String msgIdDataType = "VARCHAR(250)"; 033 protected String sequenceDataType = "BIGINT"; 034 protected String longDataType = "BIGINT"; 035 protected String stringIdDataType = "VARCHAR(250)"; 036 protected boolean useExternalMessageReferences; 037 038 private String tablePrefix = ""; 039 private String addMessageStatement; 040 private String updateMessageStatement; 041 private String removeMessageStatment; 042 private String findMessageSequenceIdStatement; 043 private String findMessageStatement; 044 private String findMessageByIdStatement; 045 private String findAllMessagesStatement; 046 private String findLastSequenceIdInMsgsStatement; 047 private String findLastSequenceIdInAcksStatement; 048 private String createDurableSubStatement; 049 private String findDurableSubStatement; 050 private String findAllDurableSubsStatement; 051 private String updateLastAckOfDurableSubStatement; 052 private String deleteSubscriptionStatement; 053 private String findAllDurableSubMessagesStatement; 054 private String findDurableSubMessagesStatement; 055 private String findAllDestinationsStatement; 056 private String removeAllMessagesStatement; 057 private String removeAllSubscriptionsStatement; 058 private String deleteOldMessagesStatement; 059 private String[] createSchemaStatements; 060 private String[] dropSchemaStatements; 061 private String lockCreateStatement; 062 private String lockUpdateStatement; 063 private String nextDurableSubscriberMessageStatement; 064 private String durableSubscriberMessageCountStatement; 065 private String lastAckedDurableSubscriberMessageStatement; 066 private String destinationMessageCountStatement; 067 private String findNextMessagesStatement; 068 private boolean useLockCreateWhereClause; 069 private String findAllMessageIdsStatement; 070 071 public String[] getCreateSchemaStatements() { 072 if (createSchemaStatements == null) { 073 createSchemaStatements = new String[] { 074 "CREATE TABLE " + getFullMessageTableName() + "(" + "ID " + sequenceDataType + " NOT NULL" 075 + ", CONTAINER " + containerNameDataType + ", MSGID_PROD " + msgIdDataType + ", MSGID_SEQ " 076 + sequenceDataType + ", EXPIRATION " + longDataType + ", MSG " 077 + (useExternalMessageReferences ? stringIdDataType : binaryDataType) 078 + ", PRIMARY KEY ( ID ) )", 079 "CREATE INDEX " + getFullMessageTableName() + "_MIDX ON " + getFullMessageTableName() + " (MSGID_PROD,MSGID_SEQ)", 080 "CREATE INDEX " + getFullMessageTableName() + "_CIDX ON " + getFullMessageTableName() + " (CONTAINER)", 081 "CREATE INDEX " + getFullMessageTableName() + "_EIDX ON " + getFullMessageTableName() + " (EXPIRATION)", 082 "CREATE TABLE " + getFullAckTableName() + "(" + "CONTAINER " + containerNameDataType + " NOT NULL" 083 + ", SUB_DEST " + stringIdDataType 084 + ", CLIENT_ID " + stringIdDataType + " NOT NULL" + ", SUB_NAME " + stringIdDataType 085 + " NOT NULL" + ", SELECTOR " + stringIdDataType + ", LAST_ACKED_ID " + sequenceDataType 086 + ", PRIMARY KEY ( CONTAINER, CLIENT_ID, SUB_NAME))", 087 "CREATE TABLE " + getFullLockTableName() 088 + "( ID " + longDataType + " NOT NULL, TIME " + longDataType 089 + ", BROKER_NAME " + stringIdDataType + ", PRIMARY KEY (ID) )", 090 "INSERT INTO " + getFullLockTableName() + "(ID) VALUES (1)", 091 }; 092 } 093 return createSchemaStatements; 094 } 095 096 public String[] getDropSchemaStatements() { 097 if (dropSchemaStatements == null) { 098 dropSchemaStatements = new String[] {"DROP TABLE " + getFullAckTableName() + "", 099 "DROP TABLE " + getFullMessageTableName() + "", 100 "DROP TABLE " + getFullLockTableName() + ""}; 101 } 102 return dropSchemaStatements; 103 } 104 105 public String getAddMessageStatement() { 106 if (addMessageStatement == null) { 107 addMessageStatement = "INSERT INTO " 108 + getFullMessageTableName() 109 + "(ID, MSGID_PROD, MSGID_SEQ, CONTAINER, EXPIRATION, MSG) VALUES (?, ?, ?, ?, ?, ?)"; 110 } 111 return addMessageStatement; 112 } 113 114 public String getUpdateMessageStatement() { 115 if (updateMessageStatement == null) { 116 updateMessageStatement = "UPDATE " + getFullMessageTableName() + " SET MSG=? WHERE ID=?"; 117 } 118 return updateMessageStatement; 119 } 120 121 public String getRemoveMessageStatment() { 122 if (removeMessageStatment == null) { 123 removeMessageStatment = "DELETE FROM " + getFullMessageTableName() + " WHERE ID=?"; 124 } 125 return removeMessageStatment; 126 } 127 128 public String getFindMessageSequenceIdStatement() { 129 if (findMessageSequenceIdStatement == null) { 130 findMessageSequenceIdStatement = "SELECT ID FROM " + getFullMessageTableName() 131 + " WHERE MSGID_PROD=? AND MSGID_SEQ=?"; 132 } 133 return findMessageSequenceIdStatement; 134 } 135 136 public String getFindMessageStatement() { 137 if (findMessageStatement == null) { 138 findMessageStatement = "SELECT MSG FROM " + getFullMessageTableName() + " WHERE MSGID_PROD=? AND MSGID_SEQ=?"; 139 } 140 return findMessageStatement; 141 } 142 143 public String getFindMessageByIdStatement() { 144 if (findMessageStatement == null) { 145 findMessageStatement = "SELECT MSG FROM " + getFullMessageTableName() + " WHERE ID=?"; 146 } 147 return findMessageStatement; 148 } 149 150 public String getFindAllMessagesStatement() { 151 if (findAllMessagesStatement == null) { 152 findAllMessagesStatement = "SELECT ID, MSG FROM " + getFullMessageTableName() 153 + " WHERE CONTAINER=? ORDER BY ID"; 154 } 155 return findAllMessagesStatement; 156 } 157 158 public String getFindAllMessageIdsStatement() { 159 // this needs to be limited maybe need to use getFindLastSequenceIdInMsgsStatement 160 // and work back for X 161 if (findAllMessageIdsStatement == null) { 162 findAllMessageIdsStatement = "SELECT ID, MSGID_PROD, MSGID_SEQ FROM " + getFullMessageTableName() 163 + " ORDER BY ID DESC"; 164 } 165 return findAllMessageIdsStatement; 166 } 167 168 public String getFindLastSequenceIdInMsgsStatement() { 169 if (findLastSequenceIdInMsgsStatement == null) { 170 findLastSequenceIdInMsgsStatement = "SELECT MAX(ID) FROM " + getFullMessageTableName(); 171 } 172 return findLastSequenceIdInMsgsStatement; 173 } 174 175 public String getFindLastSequenceIdInAcksStatement() { 176 if (findLastSequenceIdInAcksStatement == null) { 177 findLastSequenceIdInAcksStatement = "SELECT MAX(LAST_ACKED_ID) FROM " + getFullAckTableName(); 178 } 179 return findLastSequenceIdInAcksStatement; 180 } 181 182 public String getCreateDurableSubStatement() { 183 if (createDurableSubStatement == null) { 184 createDurableSubStatement = "INSERT INTO " 185 + getFullAckTableName() 186 + "(CONTAINER, CLIENT_ID, SUB_NAME, SELECTOR, LAST_ACKED_ID, SUB_DEST) " 187 + "VALUES (?, ?, ?, ?, ?, ?)"; 188 } 189 return createDurableSubStatement; 190 } 191 192 public String getFindDurableSubStatement() { 193 if (findDurableSubStatement == null) { 194 findDurableSubStatement = "SELECT SELECTOR, SUB_DEST " + "FROM " + getFullAckTableName() 195 + " WHERE CONTAINER=? AND CLIENT_ID=? AND SUB_NAME=?"; 196 } 197 return findDurableSubStatement; 198 } 199 200 public String getFindAllDurableSubsStatement() { 201 if (findAllDurableSubsStatement == null) { 202 findAllDurableSubsStatement = "SELECT SELECTOR, SUB_NAME, CLIENT_ID, SUB_DEST" + " FROM " 203 + getFullAckTableName() + " WHERE CONTAINER=?"; 204 } 205 return findAllDurableSubsStatement; 206 } 207 208 public String getUpdateLastAckOfDurableSubStatement() { 209 if (updateLastAckOfDurableSubStatement == null) { 210 updateLastAckOfDurableSubStatement = "UPDATE " + getFullAckTableName() + " SET LAST_ACKED_ID=?" 211 + " WHERE CONTAINER=? AND CLIENT_ID=? AND SUB_NAME=?"; 212 } 213 return updateLastAckOfDurableSubStatement; 214 } 215 216 public String getDeleteSubscriptionStatement() { 217 if (deleteSubscriptionStatement == null) { 218 deleteSubscriptionStatement = "DELETE FROM " + getFullAckTableName() 219 + " WHERE CONTAINER=? AND CLIENT_ID=? AND SUB_NAME=?"; 220 } 221 return deleteSubscriptionStatement; 222 } 223 224 public String getFindAllDurableSubMessagesStatement() { 225 if (findAllDurableSubMessagesStatement == null) { 226 findAllDurableSubMessagesStatement = "SELECT M.ID, M.MSG FROM " + getFullMessageTableName() 227 + " M, " + getFullAckTableName() + " D " 228 + " WHERE D.CONTAINER=? AND D.CLIENT_ID=? AND D.SUB_NAME=?" 229 + " AND M.CONTAINER=D.CONTAINER AND M.ID > D.LAST_ACKED_ID" 230 + " ORDER BY M.ID"; 231 } 232 return findAllDurableSubMessagesStatement; 233 } 234 235 public String getFindDurableSubMessagesStatement() { 236 if (findDurableSubMessagesStatement == null) { 237 findDurableSubMessagesStatement = "SELECT M.ID, M.MSG FROM " + getFullMessageTableName() + " M, " 238 + getFullAckTableName() + " D " 239 + " WHERE D.CONTAINER=? AND D.CLIENT_ID=? AND D.SUB_NAME=?" 240 + " AND M.CONTAINER=D.CONTAINER AND M.ID > ?" 241 + " ORDER BY M.ID"; 242 } 243 return findDurableSubMessagesStatement; 244 } 245 246 public String findAllDurableSubMessagesStatement() { 247 if (findAllDurableSubMessagesStatement == null) { 248 findAllDurableSubMessagesStatement = "SELECT M.ID, M.MSG FROM " + getFullMessageTableName() 249 + " M, " + getFullAckTableName() + " D " 250 + " WHERE D.CONTAINER=? AND D.CLIENT_ID=? AND D.SUB_NAME=?" 251 + " AND M.CONTAINER=D.CONTAINER AND M.ID > D.LAST_ACKED_ID" 252 + " ORDER BY M.ID"; 253 } 254 return findAllDurableSubMessagesStatement; 255 } 256 257 public String getNextDurableSubscriberMessageStatement() { 258 if (nextDurableSubscriberMessageStatement == null) { 259 nextDurableSubscriberMessageStatement = "SELECT M.ID, M.MSG FROM " 260 + getFullMessageTableName() 261 + " M, " 262 + getFullAckTableName() 263 + " D " 264 + " WHERE D.CONTAINER=? AND D.CLIENT_ID=? AND D.SUB_NAME=?" 265 + " AND M.CONTAINER=D.CONTAINER AND M.ID > ?" 266 + " ORDER BY M.ID "; 267 } 268 return nextDurableSubscriberMessageStatement; 269 } 270 271 /** 272 * @return the durableSubscriberMessageCountStatement 273 */ 274 275 public String getDurableSubscriberMessageCountStatement() { 276 if (durableSubscriberMessageCountStatement == null) { 277 durableSubscriberMessageCountStatement = "SELECT COUNT(*) FROM " 278 + getFullMessageTableName() 279 + " M, " 280 + getFullAckTableName() 281 + " D " 282 + " WHERE D.CONTAINER=? AND D.CLIENT_ID=? AND D.SUB_NAME=?" 283 + " AND M.CONTAINER=D.CONTAINER AND M.ID > D.LAST_ACKED_ID"; 284 } 285 return durableSubscriberMessageCountStatement; 286 } 287 288 public String getFindAllDestinationsStatement() { 289 if (findAllDestinationsStatement == null) { 290 findAllDestinationsStatement = "SELECT DISTINCT CONTAINER FROM " + getFullMessageTableName(); 291 } 292 return findAllDestinationsStatement; 293 } 294 295 public String getRemoveAllMessagesStatement() { 296 if (removeAllMessagesStatement == null) { 297 removeAllMessagesStatement = "DELETE FROM " + getFullMessageTableName() + " WHERE CONTAINER=?"; 298 } 299 return removeAllMessagesStatement; 300 } 301 302 public String getRemoveAllSubscriptionsStatement() { 303 if (removeAllSubscriptionsStatement == null) { 304 removeAllSubscriptionsStatement = "DELETE FROM " + getFullAckTableName() + " WHERE CONTAINER=?"; 305 } 306 return removeAllSubscriptionsStatement; 307 } 308 309 public String getDeleteOldMessagesStatement() { 310 if (deleteOldMessagesStatement == null) { 311 deleteOldMessagesStatement = "DELETE FROM " + getFullMessageTableName() 312 + " WHERE ( EXPIRATION<>0 AND EXPIRATION<?) OR ID <= " 313 + "( SELECT min(" + getFullAckTableName() + ".LAST_ACKED_ID) " 314 + "FROM " + getFullAckTableName() + " WHERE " 315 + getFullAckTableName() + ".CONTAINER=" + getFullMessageTableName() 316 + ".CONTAINER)"; 317 } 318 return deleteOldMessagesStatement; 319 } 320 321 public String getLockCreateStatement() { 322 if (lockCreateStatement == null) { 323 lockCreateStatement = "SELECT * FROM " + getFullLockTableName(); 324 if (useLockCreateWhereClause) { 325 lockCreateStatement += " WHERE ID = 1"; 326 } 327 lockCreateStatement += " FOR UPDATE"; 328 } 329 return lockCreateStatement; 330 } 331 332 public String getLockUpdateStatement() { 333 if (lockUpdateStatement == null) { 334 lockUpdateStatement = "UPDATE " + getFullLockTableName() + " SET TIME = ? WHERE ID = 1"; 335 } 336 return lockUpdateStatement; 337 } 338 339 /** 340 * @return the destinationMessageCountStatement 341 */ 342 public String getDestinationMessageCountStatement() { 343 if (destinationMessageCountStatement == null) { 344 destinationMessageCountStatement = "SELECT COUNT(*) FROM " + getFullMessageTableName() 345 + " WHERE CONTAINER=?"; 346 } 347 return destinationMessageCountStatement; 348 } 349 350 /** 351 * @return the findNextMessagesStatement 352 */ 353 public String getFindNextMessagesStatement() { 354 if (findNextMessagesStatement == null) { 355 findNextMessagesStatement = "SELECT ID, MSG FROM " + getFullMessageTableName() 356 + " WHERE CONTAINER=? AND ID > ? ORDER BY ID"; 357 } 358 return findNextMessagesStatement; 359 } 360 361 /** 362 * @return the lastAckedDurableSubscriberMessageStatement 363 */ 364 public String getLastAckedDurableSubscriberMessageStatement() { 365 if (lastAckedDurableSubscriberMessageStatement == null) { 366 lastAckedDurableSubscriberMessageStatement = "SELECT MAX(LAST_ACKED_ID) FROM " 367 + getFullAckTableName() 368 + " WHERE CONTAINER=? AND CLIENT_ID=? AND SUB_NAME=?"; 369 } 370 return lastAckedDurableSubscriberMessageStatement; 371 } 372 373 public String getFullMessageTableName() { 374 return getTablePrefix() + getMessageTableName(); 375 } 376 377 public String getFullAckTableName() { 378 return getTablePrefix() + getDurableSubAcksTableName(); 379 } 380 381 public String getFullLockTableName() { 382 return getTablePrefix() + getLockTableName(); 383 } 384 385 /** 386 * @return Returns the containerNameDataType. 387 */ 388 public String getContainerNameDataType() { 389 return containerNameDataType; 390 } 391 392 /** 393 * @param containerNameDataType The containerNameDataType to set. 394 */ 395 public void setContainerNameDataType(String containerNameDataType) { 396 this.containerNameDataType = containerNameDataType; 397 } 398 399 /** 400 * @return Returns the messageDataType. 401 */ 402 public String getBinaryDataType() { 403 return binaryDataType; 404 } 405 406 /** 407 * @param messageDataType The messageDataType to set. 408 */ 409 public void setBinaryDataType(String messageDataType) { 410 this.binaryDataType = messageDataType; 411 } 412 413 /** 414 * @return Returns the messageTableName. 415 */ 416 public String getMessageTableName() { 417 return messageTableName; 418 } 419 420 /** 421 * @param messageTableName The messageTableName to set. 422 */ 423 public void setMessageTableName(String messageTableName) { 424 this.messageTableName = messageTableName; 425 } 426 427 /** 428 * @return Returns the msgIdDataType. 429 */ 430 public String getMsgIdDataType() { 431 return msgIdDataType; 432 } 433 434 /** 435 * @param msgIdDataType The msgIdDataType to set. 436 */ 437 public void setMsgIdDataType(String msgIdDataType) { 438 this.msgIdDataType = msgIdDataType; 439 } 440 441 /** 442 * @return Returns the sequenceDataType. 443 */ 444 public String getSequenceDataType() { 445 return sequenceDataType; 446 } 447 448 /** 449 * @param sequenceDataType The sequenceDataType to set. 450 */ 451 public void setSequenceDataType(String sequenceDataType) { 452 this.sequenceDataType = sequenceDataType; 453 } 454 455 /** 456 * @return Returns the tablePrefix. 457 */ 458 public String getTablePrefix() { 459 return tablePrefix; 460 } 461 462 /** 463 * @param tablePrefix The tablePrefix to set. 464 */ 465 public void setTablePrefix(String tablePrefix) { 466 this.tablePrefix = tablePrefix; 467 } 468 469 /** 470 * @return Returns the durableSubAcksTableName. 471 */ 472 public String getDurableSubAcksTableName() { 473 return durableSubAcksTableName; 474 } 475 476 /** 477 * @param durableSubAcksTableName The durableSubAcksTableName to set. 478 */ 479 public void setDurableSubAcksTableName(String durableSubAcksTableName) { 480 this.durableSubAcksTableName = durableSubAcksTableName; 481 } 482 483 public String getLockTableName() { 484 return lockTableName; 485 } 486 487 public void setLockTableName(String lockTableName) { 488 this.lockTableName = lockTableName; 489 } 490 491 public String getLongDataType() { 492 return longDataType; 493 } 494 495 public void setLongDataType(String longDataType) { 496 this.longDataType = longDataType; 497 } 498 499 public String getStringIdDataType() { 500 return stringIdDataType; 501 } 502 503 public void setStringIdDataType(String stringIdDataType) { 504 this.stringIdDataType = stringIdDataType; 505 } 506 507 public void setUseExternalMessageReferences(boolean useExternalMessageReferences) { 508 this.useExternalMessageReferences = useExternalMessageReferences; 509 } 510 511 public boolean isUseExternalMessageReferences() { 512 return useExternalMessageReferences; 513 } 514 515 public void setAddMessageStatement(String addMessageStatment) { 516 this.addMessageStatement = addMessageStatment; 517 } 518 519 public void setCreateDurableSubStatement(String createDurableSubStatment) { 520 this.createDurableSubStatement = createDurableSubStatment; 521 } 522 523 public void setCreateSchemaStatements(String[] createSchemaStatments) { 524 this.createSchemaStatements = createSchemaStatments; 525 } 526 527 public void setDeleteOldMessagesStatement(String deleteOldMessagesStatment) { 528 this.deleteOldMessagesStatement = deleteOldMessagesStatment; 529 } 530 531 public void setDeleteSubscriptionStatement(String deleteSubscriptionStatment) { 532 this.deleteSubscriptionStatement = deleteSubscriptionStatment; 533 } 534 535 public void setDropSchemaStatements(String[] dropSchemaStatments) { 536 this.dropSchemaStatements = dropSchemaStatments; 537 } 538 539 public void setFindAllDestinationsStatement(String findAllDestinationsStatment) { 540 this.findAllDestinationsStatement = findAllDestinationsStatment; 541 } 542 543 public void setFindAllDurableSubMessagesStatement(String findAllDurableSubMessagesStatment) { 544 this.findAllDurableSubMessagesStatement = findAllDurableSubMessagesStatment; 545 } 546 547 public void setFindAllDurableSubsStatement(String findAllDurableSubsStatment) { 548 this.findAllDurableSubsStatement = findAllDurableSubsStatment; 549 } 550 551 public void setFindAllMessagesStatement(String findAllMessagesStatment) { 552 this.findAllMessagesStatement = findAllMessagesStatment; 553 } 554 555 public void setFindDurableSubStatement(String findDurableSubStatment) { 556 this.findDurableSubStatement = findDurableSubStatment; 557 } 558 559 public void setFindLastSequenceIdInAcksStatement(String findLastSequenceIdInAcks) { 560 this.findLastSequenceIdInAcksStatement = findLastSequenceIdInAcks; 561 } 562 563 public void setFindLastSequenceIdInMsgsStatement(String findLastSequenceIdInMsgs) { 564 this.findLastSequenceIdInMsgsStatement = findLastSequenceIdInMsgs; 565 } 566 567 public void setFindMessageSequenceIdStatement(String findMessageSequenceIdStatment) { 568 this.findMessageSequenceIdStatement = findMessageSequenceIdStatment; 569 } 570 571 public void setFindMessageStatement(String findMessageStatment) { 572 this.findMessageStatement = findMessageStatment; 573 } 574 575 public void setRemoveAllMessagesStatement(String removeAllMessagesStatment) { 576 this.removeAllMessagesStatement = removeAllMessagesStatment; 577 } 578 579 public void setRemoveAllSubscriptionsStatement(String removeAllSubscriptionsStatment) { 580 this.removeAllSubscriptionsStatement = removeAllSubscriptionsStatment; 581 } 582 583 public void setRemoveMessageStatment(String removeMessageStatment) { 584 this.removeMessageStatment = removeMessageStatment; 585 } 586 587 public void setUpdateLastAckOfDurableSubStatement(String updateLastAckOfDurableSub) { 588 this.updateLastAckOfDurableSubStatement = updateLastAckOfDurableSub; 589 } 590 591 public void setUpdateMessageStatement(String updateMessageStatment) { 592 this.updateMessageStatement = updateMessageStatment; 593 } 594 595 public boolean isUseLockCreateWhereClause() { 596 return useLockCreateWhereClause; 597 } 598 599 public void setUseLockCreateWhereClause(boolean useLockCreateWhereClause) { 600 this.useLockCreateWhereClause = useLockCreateWhereClause; 601 } 602 603 public void setLockCreateStatement(String lockCreateStatement) { 604 this.lockCreateStatement = lockCreateStatement; 605 } 606 607 public void setLockUpdateStatement(String lockUpdateStatement) { 608 this.lockUpdateStatement = lockUpdateStatement; 609 } 610 611 /** 612 * @param findDurableSubMessagesStatement the 613 * findDurableSubMessagesStatement to set 614 */ 615 public void setFindDurableSubMessagesStatement(String findDurableSubMessagesStatement) { 616 this.findDurableSubMessagesStatement = findDurableSubMessagesStatement; 617 } 618 619 /** 620 * @param nextDurableSubscriberMessageStatement the nextDurableSubscriberMessageStatement to set 621 */ 622 public void setNextDurableSubscriberMessageStatement(String nextDurableSubscriberMessageStatement) { 623 this.nextDurableSubscriberMessageStatement = nextDurableSubscriberMessageStatement; 624 } 625 626 /** 627 * @param durableSubscriberMessageCountStatement the durableSubscriberMessageCountStatement to set 628 */ 629 public void setDurableSubscriberMessageCountStatement(String durableSubscriberMessageCountStatement) { 630 this.durableSubscriberMessageCountStatement = durableSubscriberMessageCountStatement; 631 } 632 633 /** 634 * @param findNextMessagesStatement the findNextMessagesStatement to set 635 */ 636 public void setFindNextMessagesStatement(String findNextMessagesStatement) { 637 this.findNextMessagesStatement = findNextMessagesStatement; 638 } 639 640 /** 641 * @param destinationMessageCountStatement the destinationMessageCountStatement to set 642 */ 643 public void setDestinationMessageCountStatement(String destinationMessageCountStatement) { 644 this.destinationMessageCountStatement = destinationMessageCountStatement; 645 } 646 647 /** 648 * @param lastAckedDurableSubscriberMessageStatement the lastAckedDurableSubscriberMessageStatement to set 649 */ 650 public void setLastAckedDurableSubscriberMessageStatement( 651 String lastAckedDurableSubscriberMessageStatement) { 652 this.lastAckedDurableSubscriberMessageStatement = lastAckedDurableSubscriberMessageStatement; 653 } 654 655 }