001 // Copyright (c) 2001 Hursh Jain (http://www.mollypages.org) 002 // The Molly framework is freely distributable under the terms of an 003 // MIT-style license. For details, see the molly pages web site at: 004 // http://www.mollypages.org/. Use, modify, have fun ! 005 006 package fc.jdbc.dbo.generated; 007 008 /* 009 * Auto generated on: Wed May 13 01:41:13 EDT 2020 010 * JDBC url: [jdbc:postgresql://127.0.0.1/test] 011 * WARNING: Manual edits will be lost if/when this file is regenerated. 012 */ 013 import java.io.*; 014 import java.math.*; 015 import java.sql.*; 016 import java.util.*; 017 018 import fc.io.*; 019 import fc.jdbc.*; 020 import fc.jdbc.dbo.*; 021 import fc.util.*; 022 import fc.web.forms.*; 023 024 /** 025 Represents a row in the alltypes table. 026 */ 027 public class alltypes extends fc.jdbc.dbo.DBO 028 { 029 /* Default constructor */ 030 public alltypes() 031 { 032 this.__isNew = true; 033 } 034 035 /*--------------------- Columns ------------------------*/ 036 private int id; /** serial (INTEGER); PK=yes; Nullable=false; AutoInc=true; MaxSize=10 */ 037 private short smallint_val; /** int2 (SMALLINT); Nullable=true; AutoInc=false; MaxSize=5 */ 038 private int int_val; /** int4 (INTEGER); Nullable=false; AutoInc=false; MaxSize=10 */ 039 private long bigint_val; /** int8 (BIGINT); Nullable=true; AutoInc=false; MaxSize=19 */ 040 private float float_val; /** float4 (REAL); Nullable=true; AutoInc=false; MaxSize=8 */ 041 private double double_val; /** float8 (DOUBLE); Nullable=true; AutoInc=false; MaxSize=17 */ 042 private BigDecimal numeric_val; /** numeric (NUMERIC); Nullable=true; AutoInc=false; MaxSize=5 */ 043 private String char_val; /** bpchar (CHAR); Nullable=true; AutoInc=false; MaxSize=10 */ 044 private String varchar_val; /** varchar (VARCHAR); Nullable=true; AutoInc=false; MaxSize=10 */ 045 private String longvarchar_val; /** text (VARCHAR); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 046 private java.sql.Date date_val; /** date (DATE); Nullable=true; AutoInc=false; MaxSize=13 */ 047 private Time time_val; /** time (TIME); Nullable=true; AutoInc=false; MaxSize=15 */ 048 private Timestamp timestamp_val; /** timestamp (TIMESTAMP); Nullable=true; AutoInc=false; MaxSize=29 */ 049 private Boolean bit_val; /** bit (BIT); Nullable=true; AutoInc=false; MaxSize=1 */ 050 private java.sql.Array array_val; /** _varchar (ARRAY); Nullable=true; AutoInc=false; MaxSize=10 */ 051 private Boolean boolean_val; /** bool (BIT); Nullable=true; AutoInc=false; MaxSize=1 */ 052 private byte[] varbinary_val; /** bytea (BINARY); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 053 private String json_val; /** json (OTHER); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 054 private String jsonb_val; /** jsonb (OTHER); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 055 /*------------------------------------------------------*/ 056 /* 057 Original PK saved here for updates. If a row is retrieved from the database and 058 the PK value is changed, and then if the object is saved, we need the orignal PK 059 value to find the row in the db for our update to work. 060 */ 061 int __orig_id; 062 063 boolean __force_update = false; 064 private Map __extra_data; 065 private boolean __isNew = false; 066 private boolean __isModified = false; 067 068 private boolean __isModified_id = false; 069 protected boolean __isNullInDB_id = false; 070 /**returns <tt>true</tt> if id has changed since it was created/loaded, <tt>false</tt> otherwise*/ 071 public boolean isModified_id() { return this.__isModified_id; } 072 /**returns <tt>true</tt> if id was null in the database*/ 073 public boolean isNullInDB_id() { return this.__isNullInDB_id; } 074 075 private boolean __isModified_smallint_val = false; 076 /* this primitive type is nullable, this tracks whether we should save it as null to the database*/ 077 private boolean __isModified_smallint_val_setnull = false; 078 protected boolean __isNullInDB_smallint_val = false; 079 /**returns <tt>true</tt> if smallint_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 080 public boolean isModified_smallint_val() { return this.__isModified_smallint_val; } 081 /**returns <true> is primitive type smallint_val has been set to null via the setNull mechanism*/ 082 public boolean isModifiedSetNull_smallint_val() { return this.__isModified_smallint_val_setnull; } 083 /**returns <tt>true</tt> if smallint_val was null in the database*/ 084 public boolean isNullInDB_smallint_val() { return this.__isNullInDB_smallint_val; } 085 086 private boolean __isModified_int_val = false; 087 protected boolean __isNullInDB_int_val = false; 088 /**returns <tt>true</tt> if int_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 089 public boolean isModified_int_val() { return this.__isModified_int_val; } 090 /**returns <tt>true</tt> if int_val was null in the database*/ 091 public boolean isNullInDB_int_val() { return this.__isNullInDB_int_val; } 092 093 private boolean __isModified_bigint_val = false; 094 /* this primitive type is nullable, this tracks whether we should save it as null to the database*/ 095 private boolean __isModified_bigint_val_setnull = false; 096 protected boolean __isNullInDB_bigint_val = false; 097 /**returns <tt>true</tt> if bigint_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 098 public boolean isModified_bigint_val() { return this.__isModified_bigint_val; } 099 /**returns <true> is primitive type bigint_val has been set to null via the setNull mechanism*/ 100 public boolean isModifiedSetNull_bigint_val() { return this.__isModified_bigint_val_setnull; } 101 /**returns <tt>true</tt> if bigint_val was null in the database*/ 102 public boolean isNullInDB_bigint_val() { return this.__isNullInDB_bigint_val; } 103 104 private boolean __isModified_float_val = false; 105 /* this primitive type is nullable, this tracks whether we should save it as null to the database*/ 106 private boolean __isModified_float_val_setnull = false; 107 protected boolean __isNullInDB_float_val = false; 108 /**returns <tt>true</tt> if float_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 109 public boolean isModified_float_val() { return this.__isModified_float_val; } 110 /**returns <true> is primitive type float_val has been set to null via the setNull mechanism*/ 111 public boolean isModifiedSetNull_float_val() { return this.__isModified_float_val_setnull; } 112 /**returns <tt>true</tt> if float_val was null in the database*/ 113 public boolean isNullInDB_float_val() { return this.__isNullInDB_float_val; } 114 115 private boolean __isModified_double_val = false; 116 /* this primitive type is nullable, this tracks whether we should save it as null to the database*/ 117 private boolean __isModified_double_val_setnull = false; 118 protected boolean __isNullInDB_double_val = false; 119 /**returns <tt>true</tt> if double_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 120 public boolean isModified_double_val() { return this.__isModified_double_val; } 121 /**returns <true> is primitive type double_val has been set to null via the setNull mechanism*/ 122 public boolean isModifiedSetNull_double_val() { return this.__isModified_double_val_setnull; } 123 /**returns <tt>true</tt> if double_val was null in the database*/ 124 public boolean isNullInDB_double_val() { return this.__isNullInDB_double_val; } 125 126 private boolean __isModified_numeric_val = false; 127 protected boolean __isNullInDB_numeric_val = false; 128 /**returns <tt>true</tt> if numeric_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 129 public boolean isModified_numeric_val() { return this.__isModified_numeric_val; } 130 /**returns <tt>true</tt> if numeric_val was null in the database*/ 131 public boolean isNullInDB_numeric_val() { return this.__isNullInDB_numeric_val; } 132 133 private boolean __isModified_char_val = false; 134 protected boolean __isNullInDB_char_val = false; 135 /**returns <tt>true</tt> if char_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 136 public boolean isModified_char_val() { return this.__isModified_char_val; } 137 /**returns <tt>true</tt> if char_val was null in the database*/ 138 public boolean isNullInDB_char_val() { return this.__isNullInDB_char_val; } 139 140 private boolean __isModified_varchar_val = false; 141 protected boolean __isNullInDB_varchar_val = false; 142 /**returns <tt>true</tt> if varchar_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 143 public boolean isModified_varchar_val() { return this.__isModified_varchar_val; } 144 /**returns <tt>true</tt> if varchar_val was null in the database*/ 145 public boolean isNullInDB_varchar_val() { return this.__isNullInDB_varchar_val; } 146 147 private boolean __isModified_longvarchar_val = false; 148 protected boolean __isNullInDB_longvarchar_val = false; 149 /**returns <tt>true</tt> if longvarchar_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 150 public boolean isModified_longvarchar_val() { return this.__isModified_longvarchar_val; } 151 /**returns <tt>true</tt> if longvarchar_val was null in the database*/ 152 public boolean isNullInDB_longvarchar_val() { return this.__isNullInDB_longvarchar_val; } 153 154 private boolean __isModified_date_val = false; 155 protected boolean __isNullInDB_date_val = false; 156 /**returns <tt>true</tt> if date_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 157 public boolean isModified_date_val() { return this.__isModified_date_val; } 158 /**returns <tt>true</tt> if date_val was null in the database*/ 159 public boolean isNullInDB_date_val() { return this.__isNullInDB_date_val; } 160 161 private boolean __isModified_time_val = false; 162 protected boolean __isNullInDB_time_val = false; 163 /**returns <tt>true</tt> if time_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 164 public boolean isModified_time_val() { return this.__isModified_time_val; } 165 /**returns <tt>true</tt> if time_val was null in the database*/ 166 public boolean isNullInDB_time_val() { return this.__isNullInDB_time_val; } 167 168 private boolean __isModified_timestamp_val = false; 169 protected boolean __isNullInDB_timestamp_val = false; 170 /**returns <tt>true</tt> if timestamp_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 171 public boolean isModified_timestamp_val() { return this.__isModified_timestamp_val; } 172 /**returns <tt>true</tt> if timestamp_val was null in the database*/ 173 public boolean isNullInDB_timestamp_val() { return this.__isNullInDB_timestamp_val; } 174 175 private boolean __isModified_bit_val = false; 176 protected boolean __isNullInDB_bit_val = false; 177 /**returns <tt>true</tt> if bit_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 178 public boolean isModified_bit_val() { return this.__isModified_bit_val; } 179 /**returns <tt>true</tt> if bit_val was null in the database*/ 180 public boolean isNullInDB_bit_val() { return this.__isNullInDB_bit_val; } 181 182 private boolean __isModified_array_val = false; 183 protected boolean __isNullInDB_array_val = false; 184 /**returns <tt>true</tt> if array_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 185 public boolean isModified_array_val() { return this.__isModified_array_val; } 186 /**returns <tt>true</tt> if array_val was null in the database*/ 187 public boolean isNullInDB_array_val() { return this.__isNullInDB_array_val; } 188 189 private boolean __isModified_boolean_val = false; 190 protected boolean __isNullInDB_boolean_val = false; 191 /**returns <tt>true</tt> if boolean_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 192 public boolean isModified_boolean_val() { return this.__isModified_boolean_val; } 193 /**returns <tt>true</tt> if boolean_val was null in the database*/ 194 public boolean isNullInDB_boolean_val() { return this.__isNullInDB_boolean_val; } 195 196 private boolean __isModified_varbinary_val = false; 197 protected boolean __isNullInDB_varbinary_val = false; 198 /**returns <tt>true</tt> if varbinary_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 199 public boolean isModified_varbinary_val() { return this.__isModified_varbinary_val; } 200 /**returns <tt>true</tt> if varbinary_val was null in the database*/ 201 public boolean isNullInDB_varbinary_val() { return this.__isNullInDB_varbinary_val; } 202 203 private boolean __isModified_json_val = false; 204 protected boolean __isNullInDB_json_val = false; 205 /**returns <tt>true</tt> if json_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 206 public boolean isModified_json_val() { return this.__isModified_json_val; } 207 /**returns <tt>true</tt> if json_val was null in the database*/ 208 public boolean isNullInDB_json_val() { return this.__isNullInDB_json_val; } 209 210 private boolean __isModified_jsonb_val = false; 211 protected boolean __isNullInDB_jsonb_val = false; 212 /**returns <tt>true</tt> if jsonb_val has changed since it was created/loaded, <tt>false</tt> otherwise*/ 213 public boolean isModified_jsonb_val() { return this.__isModified_jsonb_val; } 214 /**returns <tt>true</tt> if jsonb_val was null in the database*/ 215 public boolean isNullInDB_jsonb_val() { return this.__isNullInDB_jsonb_val; } 216 217 218 /** returns <tt>true</tt> if this object is newly created and has <b>not</b> been loaded from the database, <tt>false</tt> otherwise */ 219 public boolean isNew() 220 { 221 return this.__isNew; 222 } 223 224 /** Specify <tt>true</tt> to set this object's status as newly created (and not read from a database) */ 225 protected void setNew(boolean val) 226 { 227 this.__isNew = val; 228 } 229 230 /** returns <tt>true</tt> if this object's data (for any field) has changed since it was created/loaded, <tt>false</tt> otherwise */ 231 public boolean isModified() 232 { 233 return this.__isModified; 234 } 235 236 /** Resets the modified status of this object to not-modified 237 this is useful when loading an object via a prepared statement 238 (by using various setXXX methods when we do so, we inadvertently 239 set the modified status of each field to true) 240 */ 241 void resetModified() 242 { 243 this.__isModified = false; 244 this.__isModified_id = false; 245 this.__isModified_smallint_val = false; 246 this.__isModified_smallint_val_setnull = false; 247 this.__isModified_int_val = false; 248 this.__isModified_bigint_val = false; 249 this.__isModified_bigint_val_setnull = false; 250 this.__isModified_float_val = false; 251 this.__isModified_float_val_setnull = false; 252 this.__isModified_double_val = false; 253 this.__isModified_double_val_setnull = false; 254 this.__isModified_numeric_val = false; 255 this.__isModified_char_val = false; 256 this.__isModified_varchar_val = false; 257 this.__isModified_longvarchar_val = false; 258 this.__isModified_date_val = false; 259 this.__isModified_time_val = false; 260 this.__isModified_timestamp_val = false; 261 this.__isModified_bit_val = false; 262 this.__isModified_array_val = false; 263 this.__isModified_boolean_val = false; 264 this.__isModified_varbinary_val = false; 265 this.__isModified_json_val = false; 266 this.__isModified_jsonb_val = false; 267 } 268 269 /** 270 Allows putting arbitrary object-specific data into this object. 271 This is useful to store additional query-specific columns when performing 272 arbitrary queries. For example: 273 <blockquote><pre> 274 String query = "select <font color=blue>1+1 as my_sum, 275 now() as my_time</font>, alltypesMgr.columns() 276 from alltypes"; 277 PreparedStatement ps = con.prepareStatment(query); 278 ResultSet rs = ps.executeQuery(); 279 List list = new ArrayList(); 280 while (rs.next()) { 281 <font color=green>alltypes</font> obj = alltypesMgr.getFromRS(rs); 282 obj.<font color=blue>putExtraData("my_sum"</font>, rs.getInt("my_sum")); 283 obj.<font color=blue>putExtraData("my_time"</font>, rs.getDate("my_time")); 284 } 285 //use the list later on...each <font color=green>alltypes </font>object in the list will 286 //have the extra data.. 287 </pre></blockquote> 288 */ 289 public void putExtraData(Object key, Object value) 290 { 291 synchronized (this) { 292 if (__extra_data == null) { 293 __extra_data = new HashMap(); 294 } 295 } 296 __extra_data.put(key, value); 297 } 298 /*Alias for the {@link putExtraData} method */ 299 public void put(Object key, Object value) 300 { 301 putExtraData(key, value); 302 } 303 304 /** 305 Allows retrieving arbitrary object-specific data from this object. 306 This data should have been put via the {@link #putExtraData putExtraData} 307 method prior to invoking this method 308 */ 309 public Object getExtraData(Object key) 310 { 311 synchronized (this) { 312 if (__extra_data == null) { 313 return null; 314 } 315 } 316 return __extra_data.get(key); 317 } 318 /*Alias for the {@link getExtraData} method */ 319 public Object get(Object key) 320 { 321 return getExtraData(key); 322 } 323 324 public String toString() 325 { 326 final String nl = fc.io.IOUtil.LINE_SEP; 327 StringBuffer buf = new StringBuffer(256); 328 buf.append("Class Name: [alltypes]"); 329 buf.append(" [isDiscarded=").append(this.isDiscarded()).append("]"); 330 buf.append(" [isNew=").append(this.isNew()).append("]"); 331 buf.append(" [isModified=").append(this.isModified()).append("]"); 332 buf.append(nl); 333 buf.append("Note: IsNullInDB only meaningful for existing rows (i.e., isNew=false)"); 334 buf.append(nl); 335 336 ByteArrayOutputStream out = new ByteArrayOutputStream(768); 337 TablePrinter.PrintConfig config = new TablePrinter.PrintConfig(); 338 config.setPrintBorders(false); 339 config.setCellSpacing(1); 340 config.setCellPadding(0); 341 config.setAutoFit(true); 342 TablePrinter p = new TablePrinter(7, new PrintStream(out), config); 343 p.startTable(); 344 345 p.startRow(); 346 p.printCell("PK"); 347 p.printCell("FK"); 348 p.printCell("Field"); 349 p.printCell("Value"); 350 p.printCell("isModified"); 351 p.printCell("isNullinDB"); 352 p.printCell("isSerial/AutoInc"); 353 p.endRow(); 354 355 p.startRow(); 356 p.printCell("x"); 357 p.printCell("-"); 358 p.printCell("id"); 359 p.printCell(String.valueOf(this.id)); 360 p.printCell((this.__isModified_id) ?"x":"-"); 361 p.printCell((this.__isNullInDB_id) ?"x":"-"); 362 p.printCell("x"); 363 p.endRow(); 364 365 p.startRow(); 366 p.printCell("-"); 367 p.printCell("-"); 368 p.printCell("smallint_val"); 369 p.printCell(String.valueOf(this.smallint_val)); 370 p.printCell((this.__isModified_smallint_val) ?"x":"-"); 371 p.printCell((this.__isNullInDB_smallint_val) ?"x":"-"); 372 p.printCell("-"); 373 p.endRow(); 374 375 p.startRow(); 376 p.printCell("-"); 377 p.printCell("-"); 378 p.printCell("int_val"); 379 p.printCell(String.valueOf(this.int_val)); 380 p.printCell((this.__isModified_int_val) ?"x":"-"); 381 p.printCell((this.__isNullInDB_int_val) ?"x":"-"); 382 p.printCell("-"); 383 p.endRow(); 384 385 p.startRow(); 386 p.printCell("-"); 387 p.printCell("-"); 388 p.printCell("bigint_val"); 389 p.printCell(String.valueOf(this.bigint_val)); 390 p.printCell((this.__isModified_bigint_val) ?"x":"-"); 391 p.printCell((this.__isNullInDB_bigint_val) ?"x":"-"); 392 p.printCell("-"); 393 p.endRow(); 394 395 p.startRow(); 396 p.printCell("-"); 397 p.printCell("-"); 398 p.printCell("float_val"); 399 p.printCell(String.valueOf(this.float_val)); 400 p.printCell((this.__isModified_float_val) ?"x":"-"); 401 p.printCell((this.__isNullInDB_float_val) ?"x":"-"); 402 p.printCell("-"); 403 p.endRow(); 404 405 p.startRow(); 406 p.printCell("-"); 407 p.printCell("-"); 408 p.printCell("double_val"); 409 p.printCell(String.valueOf(this.double_val)); 410 p.printCell((this.__isModified_double_val) ?"x":"-"); 411 p.printCell((this.__isNullInDB_double_val) ?"x":"-"); 412 p.printCell("-"); 413 p.endRow(); 414 415 p.startRow(); 416 p.printCell("-"); 417 p.printCell("-"); 418 p.printCell("numeric_val"); 419 p.printCell(String.valueOf(this.numeric_val)); 420 p.printCell((this.__isModified_numeric_val) ?"x":"-"); 421 p.printCell((this.__isNullInDB_numeric_val) ?"x":"-"); 422 p.printCell("-"); 423 p.endRow(); 424 425 p.startRow(); 426 p.printCell("-"); 427 p.printCell("-"); 428 p.printCell("char_val"); 429 p.printCell(String.valueOf(this.char_val)); 430 p.printCell((this.__isModified_char_val) ?"x":"-"); 431 p.printCell((this.__isNullInDB_char_val) ?"x":"-"); 432 p.printCell("-"); 433 p.endRow(); 434 435 p.startRow(); 436 p.printCell("-"); 437 p.printCell("-"); 438 p.printCell("varchar_val"); 439 p.printCell(String.valueOf(this.varchar_val)); 440 p.printCell((this.__isModified_varchar_val) ?"x":"-"); 441 p.printCell((this.__isNullInDB_varchar_val) ?"x":"-"); 442 p.printCell("-"); 443 p.endRow(); 444 445 p.startRow(); 446 p.printCell("-"); 447 p.printCell("-"); 448 p.printCell("longvarchar_val"); 449 p.printCell(String.valueOf(this.longvarchar_val)); 450 p.printCell((this.__isModified_longvarchar_val) ?"x":"-"); 451 p.printCell((this.__isNullInDB_longvarchar_val) ?"x":"-"); 452 p.printCell("-"); 453 p.endRow(); 454 455 p.startRow(); 456 p.printCell("-"); 457 p.printCell("-"); 458 p.printCell("date_val"); 459 p.printCell(String.valueOf(this.date_val)); 460 p.printCell((this.__isModified_date_val) ?"x":"-"); 461 p.printCell((this.__isNullInDB_date_val) ?"x":"-"); 462 p.printCell("-"); 463 p.endRow(); 464 465 p.startRow(); 466 p.printCell("-"); 467 p.printCell("-"); 468 p.printCell("time_val"); 469 p.printCell(String.valueOf(this.time_val)); 470 p.printCell((this.__isModified_time_val) ?"x":"-"); 471 p.printCell((this.__isNullInDB_time_val) ?"x":"-"); 472 p.printCell("-"); 473 p.endRow(); 474 475 p.startRow(); 476 p.printCell("-"); 477 p.printCell("-"); 478 p.printCell("timestamp_val"); 479 p.printCell(String.valueOf(this.timestamp_val)); 480 p.printCell((this.__isModified_timestamp_val) ?"x":"-"); 481 p.printCell((this.__isNullInDB_timestamp_val) ?"x":"-"); 482 p.printCell("-"); 483 p.endRow(); 484 485 p.startRow(); 486 p.printCell("-"); 487 p.printCell("-"); 488 p.printCell("bit_val"); 489 p.printCell(String.valueOf(this.bit_val)); 490 p.printCell((this.__isModified_bit_val) ?"x":"-"); 491 p.printCell((this.__isNullInDB_bit_val) ?"x":"-"); 492 p.printCell("-"); 493 p.endRow(); 494 495 p.startRow(); 496 p.printCell("-"); 497 p.printCell("-"); 498 p.printCell("array_val"); 499 p.printCell(String.valueOf(this.array_val)); 500 p.printCell((this.__isModified_array_val) ?"x":"-"); 501 p.printCell((this.__isNullInDB_array_val) ?"x":"-"); 502 p.printCell("-"); 503 p.endRow(); 504 505 p.startRow(); 506 p.printCell("-"); 507 p.printCell("-"); 508 p.printCell("boolean_val"); 509 p.printCell(String.valueOf(this.boolean_val)); 510 p.printCell((this.__isModified_boolean_val) ?"x":"-"); 511 p.printCell((this.__isNullInDB_boolean_val) ?"x":"-"); 512 p.printCell("-"); 513 p.endRow(); 514 515 p.startRow(); 516 p.printCell("-"); 517 p.printCell("-"); 518 p.printCell("varbinary_val"); 519 p.printCell(String.valueOf(this.varbinary_val)); 520 p.printCell((this.__isModified_varbinary_val) ?"x":"-"); 521 p.printCell((this.__isNullInDB_varbinary_val) ?"x":"-"); 522 p.printCell("-"); 523 p.endRow(); 524 525 p.startRow(); 526 p.printCell("-"); 527 p.printCell("-"); 528 p.printCell("json_val"); 529 p.printCell(String.valueOf(this.json_val)); 530 p.printCell((this.__isModified_json_val) ?"x":"-"); 531 p.printCell((this.__isNullInDB_json_val) ?"x":"-"); 532 p.printCell("-"); 533 p.endRow(); 534 535 p.startRow(); 536 p.printCell("-"); 537 p.printCell("-"); 538 p.printCell("jsonb_val"); 539 p.printCell(String.valueOf(this.jsonb_val)); 540 p.printCell((this.__isModified_jsonb_val) ?"x":"-"); 541 p.printCell((this.__isNullInDB_jsonb_val) ?"x":"-"); 542 p.printCell("-"); 543 p.endRow(); 544 545 p.endTable(); 546 buf.append(out.toString()); 547 return buf.toString(); 548 } 549 550 /** 551 Returns a map of all fields->values (as Strings) contained in this 552 object. This is useful when sending auto converting the object to JSON, etc. 553 */ 554 public Map allFieldsMap() 555 { 556 final HashMap m = new HashMap(); 557 m.put("id", String.valueOf(this.id)); 558 m.put("smallint_val", 559 ( __isModified_smallint_val ? 560 ( __isModified_smallint_val_setnull ? null : String.valueOf(this.smallint_val) ) : 561 ( __isNullInDB_smallint_val ? null : String.valueOf(this.smallint_val)))); 562 m.put("int_val", String.valueOf(this.int_val)); 563 m.put("bigint_val", 564 ( __isModified_bigint_val ? 565 ( __isModified_bigint_val_setnull ? null : String.valueOf(this.bigint_val) ) : 566 ( __isNullInDB_bigint_val ? null : String.valueOf(this.bigint_val)))); 567 m.put("float_val", 568 ( __isModified_float_val ? 569 ( __isModified_float_val_setnull ? null : String.valueOf(this.float_val) ) : 570 ( __isNullInDB_float_val ? null : String.valueOf(this.float_val)))); 571 m.put("double_val", 572 ( __isModified_double_val ? 573 ( __isModified_double_val_setnull ? null : String.valueOf(this.double_val) ) : 574 ( __isNullInDB_double_val ? null : String.valueOf(this.double_val)))); 575 m.put("numeric_val", (numeric_val == null ? null : String.valueOf(this.numeric_val))); 576 m.put("char_val", (char_val == null ? null : String.valueOf(this.char_val))); 577 m.put("varchar_val", (varchar_val == null ? null : String.valueOf(this.varchar_val))); 578 m.put("longvarchar_val", (longvarchar_val == null ? null : String.valueOf(this.longvarchar_val))); 579 m.put("date_val", (date_val == null ? null : String.valueOf(this.date_val))); 580 m.put("time_val", (time_val == null ? null : String.valueOf(this.time_val))); 581 m.put("timestamp_val", (timestamp_val == null ? null : String.valueOf(this.timestamp_val))); 582 m.put("bit_val", (bit_val == null ? null : String.valueOf(this.bit_val))); 583 m.put("array_val", (array_val == null ? null : String.valueOf(this.array_val))); 584 m.put("boolean_val", (boolean_val == null ? null : String.valueOf(this.boolean_val))); 585 m.put("varbinary_val", (varbinary_val == null ? null : String.valueOf(this.varbinary_val))); 586 m.put("json_val", (json_val == null ? null : String.valueOf(this.json_val))); 587 m.put("jsonb_val", (jsonb_val == null ? null : String.valueOf(this.jsonb_val))); 588 return m; 589 } 590 591 /* ============== Gets and Sets ============== */ 592 593 /** serial (INTEGER); PK=yes; Nullable=false; AutoInc=true; MaxSize=10 */ 594 public int get_id() { 595 return id; 596 } 597 598 /** serial (INTEGER); PK=yes; Nullable=false; AutoInc=true; MaxSize=10 */ 599 /* Generating set for set_id with non public access since it's an auto-increment column */ 600 alltypes set_id(int id) { 601 this.id = id; 602 this.__isModified_id = true; 603 this.__isModified = true; 604 return this; 605 } 606 607 /** int2 (SMALLINT); Nullable=true; AutoInc=false; MaxSize=5 */ 608 public short get_smallint_val() { 609 return smallint_val; 610 } 611 612 /** int2 (SMALLINT); Nullable=true; AutoInc=false; MaxSize=5 */ 613 public alltypes set_smallint_val(short smallint_val) { 614 this.smallint_val = smallint_val; 615 this.__isModified_smallint_val = true; 616 this.__isModified = true; 617 return this; 618 } 619 public alltypes setNull_smallint_val() 620 { 621 this.__isModified_smallint_val = true; 622 this.__isModified_smallint_val_setnull = true; 623 this.__isModified = true; 624 return this; 625 } 626 627 /** int4 (INTEGER); Nullable=false; AutoInc=false; MaxSize=10 */ 628 public int get_int_val() { 629 return int_val; 630 } 631 632 /** int4 (INTEGER); Nullable=false; AutoInc=false; MaxSize=10 */ 633 public alltypes set_int_val(int int_val) { 634 this.int_val = int_val; 635 this.__isModified_int_val = true; 636 this.__isModified = true; 637 return this; 638 } 639 640 /** int8 (BIGINT); Nullable=true; AutoInc=false; MaxSize=19 */ 641 public long get_bigint_val() { 642 return bigint_val; 643 } 644 645 /** int8 (BIGINT); Nullable=true; AutoInc=false; MaxSize=19 */ 646 public alltypes set_bigint_val(long bigint_val) { 647 this.bigint_val = bigint_val; 648 this.__isModified_bigint_val = true; 649 this.__isModified = true; 650 return this; 651 } 652 public alltypes setNull_bigint_val() 653 { 654 this.__isModified_bigint_val = true; 655 this.__isModified_bigint_val_setnull = true; 656 this.__isModified = true; 657 return this; 658 } 659 660 /** float4 (REAL); Nullable=true; AutoInc=false; MaxSize=8 */ 661 public float get_float_val() { 662 return float_val; 663 } 664 665 /** float4 (REAL); Nullable=true; AutoInc=false; MaxSize=8 */ 666 public alltypes set_float_val(float float_val) { 667 this.float_val = float_val; 668 this.__isModified_float_val = true; 669 this.__isModified = true; 670 return this; 671 } 672 public alltypes setNull_float_val() 673 { 674 this.__isModified_float_val = true; 675 this.__isModified_float_val_setnull = true; 676 this.__isModified = true; 677 return this; 678 } 679 680 /** float8 (DOUBLE); Nullable=true; AutoInc=false; MaxSize=17 */ 681 public double get_double_val() { 682 return double_val; 683 } 684 685 /** float8 (DOUBLE); Nullable=true; AutoInc=false; MaxSize=17 */ 686 public alltypes set_double_val(double double_val) { 687 this.double_val = double_val; 688 this.__isModified_double_val = true; 689 this.__isModified = true; 690 return this; 691 } 692 public alltypes setNull_double_val() 693 { 694 this.__isModified_double_val = true; 695 this.__isModified_double_val_setnull = true; 696 this.__isModified = true; 697 return this; 698 } 699 700 /** numeric (NUMERIC); Nullable=true; AutoInc=false; MaxSize=5 */ 701 public BigDecimal get_numeric_val() { 702 return numeric_val; 703 } 704 705 /** numeric (NUMERIC); Nullable=true; AutoInc=false; MaxSize=5 */ 706 public alltypes set_numeric_val(BigDecimal numeric_val) { 707 this.numeric_val = numeric_val; 708 this.__isModified_numeric_val = true; 709 this.__isModified = true; 710 return this; 711 } 712 713 /** bpchar (CHAR); Nullable=true; AutoInc=false; MaxSize=10 */ 714 public String get_char_val() { 715 return char_val; 716 } 717 718 /** bpchar (CHAR); Nullable=true; AutoInc=false; MaxSize=10 */ 719 public alltypes set_char_val(String char_val) { 720 this.char_val = char_val; 721 this.__isModified_char_val = true; 722 this.__isModified = true; 723 return this; 724 } 725 726 /** varchar (VARCHAR); Nullable=true; AutoInc=false; MaxSize=10 */ 727 public String get_varchar_val() { 728 return varchar_val; 729 } 730 731 /** varchar (VARCHAR); Nullable=true; AutoInc=false; MaxSize=10 */ 732 public alltypes set_varchar_val(String varchar_val) { 733 this.varchar_val = varchar_val; 734 this.__isModified_varchar_val = true; 735 this.__isModified = true; 736 return this; 737 } 738 739 /** text (VARCHAR); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 740 public String get_longvarchar_val() { 741 return longvarchar_val; 742 } 743 744 /** text (VARCHAR); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 745 public alltypes set_longvarchar_val(String longvarchar_val) { 746 this.longvarchar_val = longvarchar_val; 747 this.__isModified_longvarchar_val = true; 748 this.__isModified = true; 749 return this; 750 } 751 752 /** date (DATE); Nullable=true; AutoInc=false; MaxSize=13 */ 753 public java.sql.Date get_date_val() { 754 return date_val; 755 } 756 757 /** date (DATE); Nullable=true; AutoInc=false; MaxSize=13 */ 758 public alltypes set_date_val(java.sql.Date date_val) { 759 this.date_val = date_val; 760 this.__isModified_date_val = true; 761 this.__isModified = true; 762 return this; 763 } 764 765 /** time (TIME); Nullable=true; AutoInc=false; MaxSize=15 */ 766 public Time get_time_val() { 767 return time_val; 768 } 769 770 /** time (TIME); Nullable=true; AutoInc=false; MaxSize=15 */ 771 public alltypes set_time_val(Time time_val) { 772 this.time_val = time_val; 773 this.__isModified_time_val = true; 774 this.__isModified = true; 775 return this; 776 } 777 778 /** timestamp (TIMESTAMP); Nullable=true; AutoInc=false; MaxSize=29 */ 779 public Timestamp get_timestamp_val() { 780 return timestamp_val; 781 } 782 783 /** timestamp (TIMESTAMP); Nullable=true; AutoInc=false; MaxSize=29 */ 784 public alltypes set_timestamp_val(Timestamp timestamp_val) { 785 this.timestamp_val = timestamp_val; 786 this.__isModified_timestamp_val = true; 787 this.__isModified = true; 788 return this; 789 } 790 791 /** bit (BIT); Nullable=true; AutoInc=false; MaxSize=1 */ 792 public Boolean get_bit_val() { 793 return bit_val; 794 } 795 796 /** bit (BIT); Nullable=true; AutoInc=false; MaxSize=1 */ 797 public alltypes set_bit_val(Boolean bit_val) { 798 this.bit_val = bit_val; 799 this.__isModified_bit_val = true; 800 this.__isModified = true; 801 return this; 802 } 803 804 /** _varchar (ARRAY); Nullable=true; AutoInc=false; MaxSize=10 */ 805 public java.sql.Array get_array_val() { 806 return array_val; 807 } 808 809 /** _varchar (ARRAY); Nullable=true; AutoInc=false; MaxSize=10 */ 810 public alltypes set_array_val(java.sql.Array array_val) { 811 this.array_val = array_val; 812 this.__isModified_array_val = true; 813 this.__isModified = true; 814 return this; 815 } 816 817 /** bool (BIT); Nullable=true; AutoInc=false; MaxSize=1 */ 818 public Boolean get_boolean_val() { 819 return boolean_val; 820 } 821 822 /** bool (BIT); Nullable=true; AutoInc=false; MaxSize=1 */ 823 public alltypes set_boolean_val(Boolean boolean_val) { 824 this.boolean_val = boolean_val; 825 this.__isModified_boolean_val = true; 826 this.__isModified = true; 827 return this; 828 } 829 830 /** bytea (BINARY); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 831 public byte[] get_varbinary_val() { 832 return varbinary_val; 833 } 834 835 /** bytea (BINARY); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 836 public alltypes set_varbinary_val(byte[] varbinary_val) { 837 this.varbinary_val = varbinary_val; 838 this.__isModified_varbinary_val = true; 839 this.__isModified = true; 840 return this; 841 } 842 843 /** json (OTHER); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 844 public String get_json_val() { 845 return json_val; 846 } 847 848 /** json (OTHER); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 849 public alltypes set_json_val(String json_val) { 850 this.json_val = json_val; 851 this.__isModified_json_val = true; 852 this.__isModified = true; 853 return this; 854 } 855 856 /** jsonb (OTHER); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 857 public String get_jsonb_val() { 858 return jsonb_val; 859 } 860 861 /** jsonb (OTHER); Nullable=true; AutoInc=false; MaxSize=2147483647 */ 862 public alltypes set_jsonb_val(String jsonb_val) { 863 this.jsonb_val = jsonb_val; 864 this.__isModified_jsonb_val = true; 865 this.__isModified = true; 866 return this; 867 } 868 869 /* =========== Increments / Decrements =========== */ 870 871 /** Increments int_val by 1 */ 872 public alltypes inc_int_val() { 873 this.int_val = this.int_val + 1; 874 this.__isModified_int_val = true; 875 this.__isModified = true; 876 return this; 877 } 878 879 /** Increments int_val by the specified amount */ 880 public alltypes inc_int_val(int amount) { 881 this.int_val = this.int_val + amount; 882 this.__isModified_int_val = true; 883 this.__isModified = true; 884 return this; 885 } 886 887 /** Increments int_val by the specified amount, upto but not above the upper bound (bound is inclusive) */ 888 public alltypes inc_int_val(int amount, int upper_bound) { 889 this.int_val = Math.min(this.int_val + amount, upper_bound); 890 this.__isModified_int_val = true; 891 this.__isModified = true; 892 return this; 893 } 894 895 /** Decrements int_val by 1 */ 896 public alltypes dec_int_val() { 897 this.int_val = this.int_val - 1; 898 this.__isModified_int_val = true; 899 this.__isModified = true; 900 return this; 901 } 902 903 /** Decrements int_val by the specified amount */ 904 public alltypes dec_int_val(int amount) { 905 this.int_val = this.int_val - amount; 906 this.__isModified_int_val = true; 907 this.__isModified = true; 908 return this; 909 } 910 911 /** Decrements int_val by the specified amount, upto but not below the lower bound (bound is inclusive) */ 912 public alltypes dec_int_val(int amount, int lower_bound) { 913 this.int_val = Math.max(this.int_val - amount, lower_bound); 914 this.__isModified_int_val = true; 915 this.__isModified = true; 916 return this; 917 } 918 919 /** Increments bigint_val by 1 */ 920 public alltypes inc_bigint_val() { 921 this.bigint_val = this.bigint_val + 1; 922 this.__isModified_bigint_val = true; 923 this.__isModified = true; 924 return this; 925 } 926 927 /** Increments bigint_val by the specified amount */ 928 public alltypes inc_bigint_val(long amount) { 929 this.bigint_val = this.bigint_val + amount; 930 this.__isModified_bigint_val = true; 931 this.__isModified = true; 932 return this; 933 } 934 935 /** Increments bigint_val by the specified amount, upto but not above the upper bound (bound is inclusive) */ 936 public alltypes inc_bigint_val(long amount, int upper_bound) { 937 this.bigint_val = Math.min(this.bigint_val + amount, upper_bound); 938 this.__isModified_bigint_val = true; 939 this.__isModified = true; 940 return this; 941 } 942 943 /** Decrements bigint_val by 1 */ 944 public alltypes dec_bigint_val() { 945 this.bigint_val = this.bigint_val - 1; 946 this.__isModified_bigint_val = true; 947 this.__isModified = true; 948 return this; 949 } 950 951 /** Decrements bigint_val by the specified amount */ 952 public alltypes dec_bigint_val(long amount) { 953 this.bigint_val = this.bigint_val - amount; 954 this.__isModified_bigint_val = true; 955 this.__isModified = true; 956 return this; 957 } 958 959 /** Decrements bigint_val by the specified amount, upto but not below the lower bound (bound is inclusive) */ 960 public alltypes dec_bigint_val(long amount, int lower_bound) { 961 this.bigint_val = Math.max(this.bigint_val - amount, lower_bound); 962 this.__isModified_bigint_val = true; 963 this.__isModified = true; 964 return this; 965 } 966 }