1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.waarp.openr66.database.model;
21
22 import org.waarp.common.database.DbAdmin;
23 import org.waarp.common.database.DbRequest;
24 import org.waarp.common.database.DbSession;
25 import org.waarp.common.database.exception.WaarpDatabaseException;
26 import org.waarp.common.database.exception.WaarpDatabaseNoConnectionException;
27 import org.waarp.common.database.exception.WaarpDatabaseSqlException;
28 import org.waarp.common.database.model.DbModel;
29 import org.waarp.common.database.model.DbModelAbstract.DbTypeResolver;
30 import org.waarp.common.database.model.DbModelFactory;
31 import org.waarp.common.database.model.DbType;
32 import org.waarp.common.logging.SysErrLogger;
33 import org.waarp.common.logging.WaarpLogger;
34 import org.waarp.common.logging.WaarpLoggerFactory;
35 import org.waarp.openr66.database.data.DbConfiguration;
36 import org.waarp.openr66.database.data.DbHostAuth;
37 import org.waarp.openr66.database.data.DbHostConfiguration;
38 import org.waarp.openr66.database.data.DbMultipleMonitor;
39 import org.waarp.openr66.database.data.DbRule;
40 import org.waarp.openr66.database.data.DbTaskRunner;
41 import org.waarp.openr66.database.data.DbTaskRunner.Columns;
42 import org.waarp.openr66.protocol.configuration.Configuration;
43 import org.waarp.openr66.protocol.configuration.PartnerConfiguration;
44 import org.waarp.openr66.protocol.utils.R66Versions;
45
46 import java.sql.Types;
47
48 import static org.waarp.common.database.DbConstant.*;
49
50
51
52
53 public class DbModelFactoryR66 extends DbModelFactory {
54 private static final WaarpLogger logger =
55 WaarpLoggerFactory.getLogger(DbModelFactoryR66.class);
56
57 private static final String ALTER_TABLE = "ALTER TABLE ";
58 private static final String ADD_COLUMN = " ADD COLUMN ";
59
60
61
62
63
64
65
66
67
68
69
70
71 public static DbAdmin initialize(final String dbdriver, final String dbserver,
72 final String dbuser, final String dbpasswd,
73 final boolean write)
74 throws WaarpDatabaseNoConnectionException {
75 final DbType type = DbType.getFromDriver(dbdriver);
76 final DbModel dbModel;
77 switch (type) {
78 case H2:
79 dbModel = new DbModelH2R66(dbserver, dbuser, dbpasswd);
80 break;
81 case Oracle:
82 dbModel = new DbModelOracleR66(dbserver, dbuser, dbpasswd);
83 break;
84 case PostGreSQL:
85 dbModel = new DbModelPostgresqlR66();
86 break;
87 case MySQL:
88 dbModel = new DbModelMysqlR66(dbserver, dbuser, dbpasswd);
89 break;
90 case MariaDB:
91 dbModel = new DbModelMariadbR66(dbserver, dbuser, dbpasswd);
92 break;
93 default:
94 throw new WaarpDatabaseNoConnectionException(
95 "TypeDriver unknown: " + type);
96 }
97 dbModels.add(dbModel);
98 return new DbAdmin(dbModel, dbserver, dbuser, dbpasswd, write);
99 }
100
101 static boolean needUpgradeDbAllDb(final DbTypeResolver dbTypeResolver,
102 final DbSession session, String version)
103 throws WaarpDatabaseNoConnectionException {
104 if (PartnerConfiguration.isVersion2GEQVersion1(
105 R66Versions.V3_1_0.getVersion(), version)) {
106 return false;
107 }
108
109 DbRequest request = null;
110 if (PartnerConfiguration.isVersion2GEQVersion1(version,
111 R66Versions.V2_4_13.getVersion())) {
112 try {
113 request = new DbRequest(session);
114 request.select(
115 "select " + DbHostConfiguration.Columns.HOSTID.name() + " from " +
116 DbHostConfiguration.table + " where " +
117 DbHostConfiguration.Columns.HOSTID + " = '" +
118 Configuration.configuration.getHostId() + '\'');
119 request.close();
120 version = DbHostConfiguration.updateVersionDb(
121 Configuration.configuration.getHostId(),
122 R66Versions.V2_4_13.getVersion());
123 } catch (final WaarpDatabaseSqlException e) {
124 return !session.getAdmin().getDbModel().upgradeDb(session, version);
125 } finally {
126 if (request != null) {
127 request.close();
128 }
129 }
130 }
131 request = null;
132 if (PartnerConfiguration.isVersion2GEQVersion1(version,
133 R66Versions.V2_4_17.getVersion())) {
134 try {
135 request = new DbRequest(session);
136 request.select(
137 "select " + DbTaskRunner.Columns.TRANSFERINFO.name() + " from " +
138 DbTaskRunner.table + " where " + DbTaskRunner.Columns.SPECIALID +
139 " = " + ILLEGALVALUE);
140 request.close();
141 version = DbHostConfiguration.updateVersionDb(
142 Configuration.configuration.getHostId(),
143 R66Versions.V2_4_17.getVersion());
144 } catch (final WaarpDatabaseSqlException e) {
145 return !session.getAdmin().getDbModel().upgradeDb(session, version);
146 } finally {
147 if (request != null) {
148 request.close();
149 }
150 }
151 }
152 request = null;
153 if (PartnerConfiguration.isVersion2GEQVersion1(version,
154 R66Versions.V2_4_23.getVersion())) {
155 try {
156 request = new DbRequest(session);
157 request.select(
158 "select " + DbHostAuth.Columns.ISACTIVE.name() + " from " +
159 DbHostAuth.table + " where " + DbHostAuth.Columns.PORT + " = " + 0);
160 request.close();
161 version = DbHostConfiguration.updateVersionDb(
162 Configuration.configuration.getHostId(),
163 R66Versions.V2_4_23.getVersion());
164 } catch (final WaarpDatabaseSqlException e) {
165 return !session.getAdmin().getDbModel().upgradeDb(session, version);
166 } finally {
167 if (request != null) {
168 request.close();
169 }
170 }
171 }
172 if (PartnerConfiguration.isVersion2GTVersion1(version,
173 R66Versions.V2_4_25.getVersion())) {
174 if (session.getAdmin().getDbModel().upgradeDb(session, version)) {
175 version = DbHostConfiguration.updateVersionDb(
176 Configuration.configuration.getHostId(),
177 R66Versions.V2_4_25.getVersion());
178 } else {
179 return true;
180 }
181 }
182 if (PartnerConfiguration.isVersion2GTVersion1(version,
183 R66Versions.V3_0_4.getVersion())) {
184 if (session.getAdmin().getDbModel().upgradeDb(session, version)) {
185 version = DbHostConfiguration.updateVersionDb(
186 Configuration.configuration.getHostId(),
187 R66Versions.V3_0_4.getVersion());
188 } else {
189 return true;
190 }
191 }
192 if (PartnerConfiguration.isVersion2GTVersion1(version,
193 R66Versions.V3_1_0.getVersion())) {
194 if (session.getAdmin().getDbModel().upgradeDb(session, version)) {
195 DbHostConfiguration.updateVersionDb(
196 Configuration.configuration.getHostId(),
197 R66Versions.V3_1_0.getVersion());
198 } else {
199 return true;
200 }
201 }
202 return false;
203 }
204
205 static DbRequest subCreateTableMariaDbMySQLH2PostgreSQL(
206 final DbTypeResolver dbTypeResolver, final DbSession session,
207 final String createTableH2, final String primaryKey, final String notNull)
208 throws WaarpDatabaseNoConnectionException {
209
210 StringBuilder action =
211 new StringBuilder(createTableH2 + DbMultipleMonitor.table + '(');
212 final DbMultipleMonitor.Columns[] mcolumns =
213 DbMultipleMonitor.Columns.values();
214 for (int i = 0; i < mcolumns.length - 1; i++) {
215 action.append(mcolumns[i].name())
216 .append(dbTypeResolver.getType(DbMultipleMonitor.dbTypes[i]))
217 .append(notNull).append(", ");
218 }
219 action.append(mcolumns[mcolumns.length - 1].name()).append(
220 dbTypeResolver.getType(DbMultipleMonitor.dbTypes[mcolumns.length - 1]))
221 .append(primaryKey).append(')');
222 SysErrLogger.FAKE_LOGGER.sysout(action);
223 if (executeRequestAction(session, action)) {
224 return null;
225 }
226 try {
227 final DbMultipleMonitor multipleMonitor =
228 new DbMultipleMonitor(Configuration.configuration.getHostId(), 0, 0,
229 0);
230 if (!multipleMonitor.exist()) {
231 multipleMonitor.insert();
232 }
233 } catch (final WaarpDatabaseException e1) {
234 SysErrLogger.FAKE_LOGGER.ignoreLog(e1);
235 }
236
237
238 action = new StringBuilder(createTableH2 + DbConfiguration.table + '(');
239 final DbConfiguration.Columns[] ccolumns = DbConfiguration.Columns.values();
240 for (int i = 0; i < ccolumns.length - 1; i++) {
241 action.append(ccolumns[i].name())
242 .append(dbTypeResolver.getType(DbConfiguration.dbTypes[i]))
243 .append(notNull).append(", ");
244 }
245 action.append(ccolumns[ccolumns.length - 1].name()).append(
246 dbTypeResolver.getType(DbConfiguration.dbTypes[ccolumns.length - 1]))
247 .append(primaryKey).append(')');
248 SysErrLogger.FAKE_LOGGER.sysout(action);
249 if (executeRequestAction(session, action)) {
250 return null;
251 }
252
253
254 action = new StringBuilder(createTableH2 + DbHostConfiguration.table + '(');
255 final DbHostConfiguration.Columns[] chcolumns =
256 DbHostConfiguration.Columns.values();
257 for (int i = 0; i < chcolumns.length - 1; i++) {
258 action.append(chcolumns[i].name())
259 .append(dbTypeResolver.getType(DbHostConfiguration.dbTypes[i]))
260 .append(notNull).append(", ");
261 }
262 action.append(chcolumns[chcolumns.length - 1].name()).append(
263 dbTypeResolver.getType(
264 DbHostConfiguration.dbTypes[chcolumns.length - 1]))
265 .append(primaryKey).append(')');
266 SysErrLogger.FAKE_LOGGER.sysout(action);
267 if (executeRequestAction(session, action)) {
268 return null;
269 }
270
271
272 action = new StringBuilder(createTableH2 + DbHostAuth.table + '(');
273 final DbHostAuth.Columns[] hcolumns = DbHostAuth.Columns.values();
274 for (int i = 0; i < hcolumns.length - 1; i++) {
275 action.append(hcolumns[i].name())
276 .append(dbTypeResolver.getType(DbHostAuth.dbTypes[i]))
277 .append(notNull).append(", ");
278 }
279 action.append(hcolumns[hcolumns.length - 1].name()).append(
280 dbTypeResolver.getType(DbHostAuth.dbTypes[hcolumns.length - 1]))
281 .append(primaryKey).append(')');
282 SysErrLogger.FAKE_LOGGER.sysout(action);
283 if (executeRequestAction(session, action)) {
284 return null;
285 }
286
287
288 action = new StringBuilder(createTableH2 + DbRule.table + '(');
289 final DbRule.Columns[] rcolumns = DbRule.Columns.values();
290 for (int i = 0; i < rcolumns.length - 1; i++) {
291 action.append(rcolumns[i].name())
292 .append(dbTypeResolver.getType(DbRule.dbTypes[i])).append(", ");
293 }
294 action.append(rcolumns[rcolumns.length - 1].name())
295 .append(dbTypeResolver.getType(DbRule.dbTypes[rcolumns.length - 1]))
296 .append(primaryKey).append(')');
297 SysErrLogger.FAKE_LOGGER.sysout(action);
298 if (executeRequestAction(session, action)) {
299 return null;
300 }
301
302
303 action = new StringBuilder(createTableH2 + DbTaskRunner.table + '(');
304 final DbTaskRunner.Columns[] acolumns = DbTaskRunner.Columns.values();
305 for (int i = 0; i < acolumns.length; i++) {
306 action.append(acolumns[i].name())
307 .append(dbTypeResolver.getType(DbTaskRunner.dbTypes[i]))
308 .append(notNull);
309 if (DbTaskRunner.dbTypes[i] == Types.TIMESTAMP) {
310 action.append(" DEFAULT CURRENT_TIMESTAMP(3)");
311 }
312 action.append(", ");
313 }
314
315 action.append(" CONSTRAINT runner_pk ").append(primaryKey).append('(');
316 for (int i = 0; i < DbTaskRunner.PRIMARY_KEY.length - 1; i++) {
317 action.append(DbTaskRunner.PRIMARY_KEY[i]).append(',');
318 }
319 action.append(DbTaskRunner.PRIMARY_KEY[DbTaskRunner.PRIMARY_KEY.length - 1])
320 .append("))");
321 SysErrLogger.FAKE_LOGGER.sysout(action);
322 if (executeRequestAction(session, action)) {
323 return null;
324 }
325 DbRequest request = null;
326 try {
327 request = new DbRequest(session);
328 if (!DbModelFactoryR66.createIndex30(dbTypeResolver, request)) {
329 return null;
330 }
331 } finally {
332 if (request != null) {
333 request.close();
334 }
335 }
336 return new DbRequest(session);
337 }
338
339 static boolean upgradeTable30(final DbTypeResolver dbTypeResolver,
340 final DbRequest request, final String modify,
341 final String type, final String notNull) {
342 final String alter = "ALTER TABLE ";
343 try {
344 SysErrLogger.FAKE_LOGGER.sysout("Start Schema Upgrading Types for: " +
345 dbTypeResolver.getDbType().name());
346
347 {
348 final String changeType = alter + DbMultipleMonitor.table + modify;
349 final DbMultipleMonitor.Columns[] mcolumns =
350 DbMultipleMonitor.Columns.values();
351 for (int i = 0; i < mcolumns.length; i++) {
352 request.query(changeType + mcolumns[i].name() + type +
353 dbTypeResolver.getType(DbMultipleMonitor.dbTypes[i]) +
354 notNull);
355 }
356 }
357
358 {
359 final String changeType = alter + DbConfiguration.table + modify;
360 final DbConfiguration.Columns[] mcolumns =
361 DbConfiguration.Columns.values();
362 for (int i = 0; i < mcolumns.length; i++) {
363 request.query(changeType + mcolumns[i].name() + type +
364 dbTypeResolver.getType(DbConfiguration.dbTypes[i]) +
365 notNull);
366 }
367 }
368
369 {
370 final String changeType = alter + DbHostConfiguration.table + modify;
371 final DbHostConfiguration.Columns[] mcolumns =
372 DbHostConfiguration.Columns.values();
373 for (int i = 0; i < mcolumns.length; i++) {
374 request.query(changeType + mcolumns[i].name() + type +
375 dbTypeResolver.getType(DbHostConfiguration.dbTypes[i]) +
376 notNull);
377 }
378 }
379
380 {
381 final String changeType = alter + DbHostAuth.table + modify;
382 final DbHostAuth.Columns[] mcolumns = DbHostAuth.Columns.values();
383 for (int i = 0; i < mcolumns.length; i++) {
384 request.query(changeType + mcolumns[i].name() + type +
385 dbTypeResolver.getType(DbHostAuth.dbTypes[i]) +
386 notNull);
387 }
388 }
389
390 {
391 final String changeType = alter + DbRule.table + modify;
392 final DbRule.Columns[] mcolumns = DbRule.Columns.values();
393 for (int i = 0; i < mcolumns.length; i++) {
394 request.query(changeType + mcolumns[i].name() + type +
395 dbTypeResolver.getType(DbRule.dbTypes[i]) + notNull);
396 }
397 }
398
399 {
400 final String changeType = alter + DbTaskRunner.table + modify;
401 final DbTaskRunner.Columns[] mcolumns = DbTaskRunner.Columns.values();
402 for (int i = 0; i < mcolumns.length; i++) {
403 request.query(changeType + mcolumns[i].name() + type +
404 dbTypeResolver.getType(DbTaskRunner.dbTypes[i]) +
405 notNull);
406 }
407 }
408 return true;
409 } catch (final Exception e) {
410 logger.warn("Error during update tables {}", e.getMessage());
411 }
412 return false;
413 }
414
415 static boolean createIndex30(final DbTypeResolver dbTypeResolver,
416 final DbRequest request) {
417 final String createIndex;
418 if (containsDbType(DbType.MySQL, DbType.Oracle)) {
419 createIndex = "CREATE INDEX ";
420 } else {
421 createIndex = "CREATE INDEX IF NOT EXISTS ";
422 }
423 StringBuilder action;
424
425 {
426 action = new StringBuilder(
427 createIndex + " IDX_CONFIG ON " + DbConfiguration.table + '(');
428 final DbConfiguration.Columns[] icolumns = DbConfiguration.indexes;
429 for (int i = 0; i < icolumns.length - 1; i++) {
430 action.append(icolumns[i].name()).append(", ");
431 }
432 action.append(icolumns[icolumns.length - 1].name()).append(')');
433 SysErrLogger.FAKE_LOGGER.sysout(action);
434 try {
435 request.query(action.toString());
436 } catch (final WaarpDatabaseNoConnectionException e) {
437 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
438 return false;
439 } catch (final WaarpDatabaseSqlException e) {
440 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
441
442 }
443 }
444
445
446 {
447 action = new StringBuilder(
448 createIndex + " IDX_HOSTCONF ON " + DbHostConfiguration.table + '(');
449 final DbHostConfiguration.Columns[] icolumns =
450 DbHostConfiguration.indexes;
451 for (int i = 0; i < icolumns.length - 1; i++) {
452 action.append(icolumns[i].name()).append(", ");
453 }
454 action.append(icolumns[icolumns.length - 1].name()).append(')');
455 SysErrLogger.FAKE_LOGGER.sysout(action);
456 try {
457 request.query(action.toString());
458 } catch (final WaarpDatabaseNoConnectionException e) {
459 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
460 return false;
461 } catch (final WaarpDatabaseSqlException e) {
462 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
463
464 }
465 }
466
467
468 {
469 action = new StringBuilder(
470 createIndex + " IDX_HOST ON " + DbHostAuth.table + '(');
471 final DbHostAuth.Columns[] icolumns = DbHostAuth.indexes;
472 for (int i = 0; i < icolumns.length - 1; i++) {
473 action.append(icolumns[i].name()).append(", ");
474 }
475 action.append(icolumns[icolumns.length - 1].name()).append(')');
476 SysErrLogger.FAKE_LOGGER.sysout(action);
477 try {
478 request.query(action.toString());
479 } catch (final WaarpDatabaseNoConnectionException e) {
480 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
481 return false;
482 } catch (final WaarpDatabaseSqlException e) {
483 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
484
485 }
486 }
487
488
489 {
490 action =
491 new StringBuilder(createIndex + " IDX_RULE ON " + DbRule.table + '(');
492 final DbRule.Columns[] icolumns = DbRule.indexes;
493 for (int i = 0; i < icolumns.length - 1; i++) {
494 action.append(icolumns[i].name()).append(", ");
495 }
496 action.append(icolumns[icolumns.length - 1].name()).append(')');
497 SysErrLogger.FAKE_LOGGER.sysout(action);
498 try {
499 request.query(action.toString());
500 } catch (final WaarpDatabaseNoConnectionException e) {
501 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
502 return false;
503 } catch (final WaarpDatabaseSqlException e) {
504 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
505
506 }
507 }
508
509 for (int j = 0; j < DbTaskRunner.indexesNames.length; j++) {
510 final String name = DbTaskRunner.indexesNames[j];
511 action = new StringBuilder(
512 createIndex + name + " ON " + DbTaskRunner.table + '(');
513 final DbTaskRunner.Columns[] idxcolumns = DbTaskRunner.indexes[j];
514 for (int i = 0; i < idxcolumns.length - 1; i++) {
515 action.append(idxcolumns[i].name()).append(", ");
516 }
517 action.append(idxcolumns[idxcolumns.length - 1].name()).append(')');
518 SysErrLogger.FAKE_LOGGER.sysout(action);
519 try {
520 request.query(action.toString());
521 } catch (final WaarpDatabaseNoConnectionException e) {
522 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
523 return false;
524 } catch (final WaarpDatabaseSqlException e) {
525 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
526
527 }
528 }
529 try {
530 if (dbTypeResolver.getDbType() == DbType.PostGreSQL) {
531 String saction = "DROP INDEX IF EXISTS GIST_FOLLOWID_IDX";
532 SysErrLogger.FAKE_LOGGER.sysout(saction);
533 request.query(saction);
534 saction = "DROP EXTENSION IF EXISTS pg_trgm";
535 SysErrLogger.FAKE_LOGGER.sysout(saction);
536 request.query(saction);
537 }
538 final String saction =
539 createIndex + " FOLLOWID_IDX ON " + DbTaskRunner.table + " (" +
540 Columns.TRANSFERINFO.name() + ", " + Columns.OWNERREQ.name() + ")";
541 SysErrLogger.FAKE_LOGGER.sysout(saction);
542 request.query(saction);
543 } catch (final WaarpDatabaseNoConnectionException e) {
544 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
545 return false;
546 } catch (final WaarpDatabaseSqlException e) {
547 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
548
549 }
550 return true;
551 }
552
553 private static boolean executeRequestAction(final DbSession session,
554 final StringBuilder action)
555 throws WaarpDatabaseNoConnectionException {
556 return executeRequestAction(session, action.toString());
557 }
558
559 private static boolean executeRequestAction(final DbSession session,
560 final String action)
561 throws WaarpDatabaseNoConnectionException {
562 final DbRequest request;
563 request = new DbRequest(session);
564 try {
565 request.query(action);
566 } catch (final WaarpDatabaseNoConnectionException e) {
567 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
568 return true;
569 } catch (final WaarpDatabaseSqlException e) {
570 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
571
572 } finally {
573 request.close();
574 }
575 return false;
576 }
577
578 static void createTableMariaDbMySQL(final DbTypeResolver dbTypeResolver,
579 final DbSession session)
580 throws WaarpDatabaseNoConnectionException {
581
582 final String createTableH2 = "CREATE TABLE IF NOT EXISTS ";
583 final String primaryKey = " PRIMARY KEY ";
584 final String notNull = " NOT NULL ";
585 final DbRequest request =
586 subCreateTableMariaDbMySQLH2PostgreSQL(dbTypeResolver, session,
587 createTableH2, primaryKey,
588 notNull);
589 if (request == null) {
590 return;
591 }
592 request.close();
593 StringBuilder action;
594
595 boolean sequenceDone = false;
596 if (dbTypeResolver.getDbType() == DbType.MariaDB) {
597
598 try {
599 final long minimalValue = System.currentTimeMillis() + 1;
600 action = new StringBuilder(
601 "CREATE SEQUENCE IF NOT EXISTS " + DbTaskRunner.fieldseq +
602 " MINVALUE " + (ILLEGALVALUE + 1) + " START WITH " + minimalValue);
603 SysErrLogger.FAKE_LOGGER.sysout(action);
604 try {
605 request.query(action.toString());
606 sequenceDone = true;
607 } catch (final WaarpDatabaseNoConnectionException e) {
608 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
609 return;
610 } catch (final WaarpDatabaseSqlException e) {
611 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
612
613 }
614 } finally {
615 request.close();
616 }
617 }
618 if (!sequenceDone) {
619
620
621
622 action = new StringBuilder(
623 "CREATE TABLE IF NOT EXISTS Sequences (name VARCHAR(22) NOT NULL " +
624 "PRIMARY KEY, seq BIGINT NOT NULL)");
625 SysErrLogger.FAKE_LOGGER.sysout(action);
626 if (executeRequestAction(session, action)) {
627 return;
628 }
629 final long minimalValue = System.currentTimeMillis() + 1;
630 action = new StringBuilder("INSERT INTO Sequences (name, seq) VALUES ('" +
631 DbTaskRunner.fieldseq + "', " + minimalValue +
632 ')');
633 SysErrLogger.FAKE_LOGGER.sysout(action);
634 if (executeRequestAction(session, action)) {
635 return;
636 }
637 }
638
639 DbHostConfiguration.updateVersionDb(Configuration.configuration.getHostId(),
640 R66Versions.V3_1_0.getVersion());
641 }
642
643 static boolean upgradeDbMariaDbMySQL(final DbTypeResolver dbTypeResolver,
644 final DbSession session,
645 final String version)
646 throws WaarpDatabaseNoConnectionException {
647 if (PartnerConfiguration.isVersion2GEQVersion1(
648 R66Versions.V3_1_0.getVersion(), version)) {
649 return true;
650 }
651 if (PartnerConfiguration.isVersion2GEQVersion1(version,
652 R66Versions.V2_4_13.getVersion())) {
653 SysErrLogger.FAKE_LOGGER.sysout(
654 version + " to " + R66Versions.V2_4_13.getVersion() + "? " + true);
655 final String createTableH2 = "CREATE TABLE IF NOT EXISTS ";
656 final String primaryKey = " PRIMARY KEY ";
657 final String notNull = " NOT NULL ";
658
659
660 final StringBuilder action =
661 new StringBuilder(createTableH2 + DbHostConfiguration.table + '(');
662 final DbHostConfiguration.Columns[] chcolumns =
663 DbHostConfiguration.Columns.values();
664 for (int i = 0; i < chcolumns.length - 1; i++) {
665 action.append(chcolumns[i].name())
666 .append(dbTypeResolver.getType(DbHostConfiguration.dbTypes[i]))
667 .append(notNull).append(", ");
668 }
669 action.append(chcolumns[chcolumns.length - 1].name()).append(
670 dbTypeResolver.getType(
671 DbHostConfiguration.dbTypes[chcolumns.length - 1]))
672 .append(primaryKey).append(')');
673 SysErrLogger.FAKE_LOGGER.sysout(action);
674 if (executeRequestAction(session, action)) {
675 return false;
676 }
677 }
678 if (PartnerConfiguration.isVersion2GEQVersion1(version,
679 R66Versions.V2_4_17.getVersion())) {
680 SysErrLogger.FAKE_LOGGER.sysout(
681 version + " to " + R66Versions.V2_4_17.getVersion() + "? " + true);
682 final DbRequest request = new DbRequest(session);
683 try {
684 final String command = ALTER_TABLE + DbTaskRunner.table + ADD_COLUMN +
685 DbTaskRunner.Columns.TRANSFERINFO.name() + ' ' +
686 dbTypeResolver.getType(
687 DbTaskRunner.dbTypes[DbTaskRunner.Columns.TRANSFERINFO.ordinal()]);
688 request.query(command);
689 } catch (final WaarpDatabaseSqlException e) {
690 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
691
692 } finally {
693 request.close();
694 }
695 }
696 if (PartnerConfiguration.isVersion2GEQVersion1(version,
697 R66Versions.V2_4_23.getVersion())) {
698 SysErrLogger.FAKE_LOGGER.sysout(
699 version + " to " + R66Versions.V2_4_23.getVersion() + "? " + true);
700 final DbRequest request = new DbRequest(session);
701 try {
702 String command = ALTER_TABLE + DbHostAuth.table + ADD_COLUMN +
703 DbHostAuth.Columns.ISACTIVE.name() + ' ' +
704 dbTypeResolver.getType(
705 DbHostAuth.dbTypes[DbHostAuth.Columns.ISACTIVE.ordinal()]);
706 request.query(command);
707 command = "UPDATE " + DbHostAuth.table + " SET " +
708 DbHostAuth.Columns.ISACTIVE.name() + " = " + true;
709 request.query(command);
710 } catch (final WaarpDatabaseSqlException e) {
711 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
712
713 } finally {
714 request.close();
715 }
716 try {
717 String command = ALTER_TABLE + DbHostAuth.table + ADD_COLUMN +
718 DbHostAuth.Columns.ISPROXIFIED.name() + ' ' +
719 dbTypeResolver.getType(
720 DbHostAuth.dbTypes[DbHostAuth.Columns.ISPROXIFIED.ordinal()]);
721 request.query(command);
722 command = "UPDATE " + DbHostAuth.table + " SET " +
723 DbHostAuth.Columns.ISPROXIFIED.name() + " = " + false;
724 request.query(command);
725 } catch (final WaarpDatabaseSqlException e) {
726 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
727
728 } finally {
729 request.close();
730 }
731 }
732 if (PartnerConfiguration.isVersion2GTVersion1(version,
733 R66Versions.V2_4_25.getVersion())) {
734 SysErrLogger.FAKE_LOGGER.sysout(
735 version + " to " + R66Versions.V2_4_25.getVersion() + "? " + true);
736 String command = ALTER_TABLE + DbTaskRunner.table + " MODIFY " +
737 DbTaskRunner.Columns.FILENAME.name() + ' ' +
738 dbTypeResolver.getType(
739 DbTaskRunner.dbTypes[DbTaskRunner.Columns.FILENAME.ordinal()]) +
740 " NOT NULL ";
741 if (executeRequestAction(session, command)) {
742 return false;
743 }
744 command = ALTER_TABLE + DbTaskRunner.table + " MODIFY " +
745 DbTaskRunner.Columns.ORIGINALNAME.name() + ' ' +
746 dbTypeResolver.getType(
747 DbTaskRunner.dbTypes[DbTaskRunner.Columns.ORIGINALNAME.ordinal()]) +
748 " NOT NULL ";
749 if (executeRequestAction(session, command)) {
750 return false;
751 }
752 }
753 if (PartnerConfiguration.isVersion2GTVersion1(version,
754 R66Versions.V3_0_4.getVersion())) {
755 SysErrLogger.FAKE_LOGGER.sysout(
756 version + " to " + R66Versions.V3_0_4.getVersion() + "? " + true);
757 final DbRequest request = new DbRequest(session);
758
759 DbModelFactoryR66.upgradeTable30(dbTypeResolver, request, " MODIFY ", " ",
760 " NOT NULL ");
761 String onTable = " ON " + DbTaskRunner.table;
762 if (containsDbType(DbType.Oracle, DbType.PostGreSQL, DbType.H2)) {
763 onTable = "";
764 }
765 try {
766 final String command = "DROP INDEX IDX_RUNNER " + onTable;
767 try {
768 SysErrLogger.FAKE_LOGGER.sysout("Command: " + command);
769 request.query(command);
770 } catch (final WaarpDatabaseNoConnectionException e) {
771 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
772 return false;
773 } catch (final WaarpDatabaseSqlException e) {
774 SysErrLogger.FAKE_LOGGER.ignoreLog(e);
775
776 }
777 DbModelFactoryR66.createIndex30(dbTypeResolver, request);
778 } finally {
779 request.close();
780 }
781 }
782 DbHostConfiguration.updateVersionDb(Configuration.configuration.getHostId(),
783 R66Versions.V3_1_0.getVersion());
784 return true;
785 }
786 }