@Override
public java.util.List<gen.model.test.Clicked> search(
org.revenj.patterns.Specification<gen.model.test.Clicked> specification,
Integer limit,
Integer offset) {
final String selectType = "SELECT it";
java.util.function.Consumer<java.sql.PreparedStatement> applyFilters = ps -> {};
java.sql.Connection connection = getConnection();
try (org.revenj.postgres.PostgresWriter pgWriter =
org.revenj.postgres.PostgresWriter.create()) {
String sql;
if (specification == null) {
sql = "SELECT r FROM \"test\".\"Clicked_event\" r";
} else if (specification instanceof gen.model.test.Clicked.BetweenNumbers) {
gen.model.test.Clicked.BetweenNumbers spec =
(gen.model.test.Clicked.BetweenNumbers) specification;
sql = selectType + " FROM \"test\".\"Clicked.BetweenNumbers\"(?, ?, ?) it";
applyFilters =
applyFilters.andThen(
ps -> {
try {
ps.setBigDecimal(1, spec.getMin());
} catch (Exception e) {
throw new RuntimeException(e);
}
});
applyFilters =
applyFilters.andThen(
ps -> {
try {
Object[] __arr = new Object[spec.getInSet().size()];
int __ind = 0;
for (Object __it : spec.getInSet()) __arr[__ind++] = __it;
ps.setArray(2, connection.createArrayOf("numeric", __arr));
} catch (Exception e) {
throw new RuntimeException(e);
}
});
applyFilters =
applyFilters.andThen(
ps -> {
try {
if (spec.getEn() == null) ps.setNull(3, java.sql.Types.OTHER);
else {
org.postgresql.util.PGobject __pgo = new org.postgresql.util.PGobject();
__pgo.setType("\"test\".\"En\"");
__pgo.setValue(
gen.model.test.converters.EnConverter.stringValue(spec.getEn()));
ps.setObject(3, __pgo);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
});
} else {
org.revenj.patterns.Query<gen.model.test.Clicked> query = query(specification);
if (offset != null) {
query = query.skip(offset);
}
if (limit != null) {
query = query.limit(limit);
}
try {
return query.list();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
if (limit != null) {
sql += " LIMIT " + Integer.toString(limit);
}
if (offset != null) {
sql += " OFFSET " + Integer.toString(offset);
}
try (java.sql.PreparedStatement statement = connection.prepareStatement(sql)) {
applyFilters.accept(statement);
return readFromDb(statement, new java.util.ArrayList<>());
} catch (java.sql.SQLException | java.io.IOException e) {
throw new RuntimeException(e);
}
} finally {
releaseConnection(connection);
}
}
@Override
public String[] submit(java.util.Collection<gen.model.test.Clicked> domainEvents) {
java.sql.Connection connection = getConnection();
try (java.sql.PreparedStatement statement =
connection.prepareStatement(
"/*NO LOAD BALANCE*/SELECT \"URI\" FROM \"test\".\"submit_Clicked\"(?)");
org.revenj.postgres.PostgresWriter sw = org.revenj.postgres.PostgresWriter.create()) {
if (prepareEvents != null) prepareEvents.accept(domainEvents);
String[] result = new String[domainEvents.size()];
org.revenj.postgres.converters.PostgresTuple tuple =
org.revenj.postgres.converters.ArrayTuple.create(domainEvents, converter::to);
org.postgresql.util.PGobject pgo = new org.postgresql.util.PGobject();
pgo.setType("\"test\".\"Clicked_event\"[]");
tuple.buildTuple(sw, false);
pgo.setValue(sw.toString());
statement.setObject(1, pgo);
try (java.sql.ResultSet rs = statement.executeQuery()) {
for (int i = 0; i < result.length; i++) {
rs.next();
result[i] = rs.getString(1);
}
}
if (assignUris != null) assignUris.accept(domainEvents, result);
return result;
} catch (java.sql.SQLException e) {
throw new RuntimeException(e);
} finally {
releaseConnection(connection);
}
}
/**
* Insert transportation routes
*
* @param transportationRouteList List of transportation routes to insert (id == null)
* @throws Exception
*/
public void insertTransportationRoutes(Collection<TransportationRoute> transportationRouteList)
throws Exception {
try {
String query =
String.format(
"INSERT INTO %s (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
table,
id,
name,
validFrom,
validUntil,
transportationID,
operator,
network,
extRef,
description,
descriptionFrom,
descriptionTo,
routeNo);
PreparedStatement ps = ConnectionManager.getInstance().prepareStatement(query);
for (TransportationRoute transportationRoute : transportationRouteList) {
if (transportationRoute.getId() != null || transportationRoute.getType() == null) {
continue;
}
transportationRoute.setId(UUID.randomUUID());
PGobject toInsertUUID = new PGobject();
toInsertUUID.setType("uuid");
toInsertUUID.setValue(String.valueOf(transportationRoute.getId()));
ps.setObject(1, toInsertUUID);
ps.setString(2, transportationRoute.getName());
ps.setTimestamp(3, transportationRoute.getValidFrom());
ps.setTimestamp(4, transportationRoute.getValidUntil());
ps.setObject(5, transportationRoute.getType().getId());
ps.setString(6, transportationRoute.getOperator());
ps.setString(7, transportationRoute.getNetwork());
ps.setString(8, transportationRoute.getExtRef());
ps.setString(9, transportationRoute.getDescription());
ps.setString(10, transportationRoute.getDescriptionFrom());
ps.setString(11, transportationRoute.getDescriptionTo());
ps.setString(12, transportationRoute.getRouteNo());
ps.addBatch();
}
ps.executeBatch();
ps.close();
ScheduleDAO scheduleDAO = new ScheduleDAO();
scheduleDAO.insertOrUpdateSchedules(transportationRouteList);
} catch (Exception e) {
ConnectionManager.getInstance().closeConnection(true);
throw new Exception("Transportation route insert failed: " + e.getMessage());
}
}
@Override
public void nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
throws HibernateException, SQLException {
try {
final String json = value == null ? null : objectMapper.writeValueAsString(value);
// otherwise PostgreSQL won't recognize the type
PGobject pgo = new PGobject();
pgo.setType("jsonb");
pgo.setValue(json);
st.setObject(index, pgo);
} catch (JsonProcessingException ex) {
throw new HibernateException(ex);
}
}
@Override
public Object mapParam(final Object value, final Connection connection) {
if (value == null) {
return null;
}
Object result = value;
if (clazz.isEnum()) {
// HACK: should be implemented in PgTypeHelper
final PGobject pgobj = new PGobject();
pgobj.setType(typeName);
try {
pgobj.setValue(((Enum<?>) value).name());
} catch (final SQLException ex) {
if (sensitive) {
LOG.error("Failed to set PG object value (sensitive parameter, stacktrace hidden)");
} else {
LOG.error("Failed to set PG object value", ex);
}
}
result = pgobj;
} else {
try {
result = PgTypeHelper.asPGobject(value, typeName, connection);
} catch (final SQLException ex) {
if (sensitive) {
LOG.error("Failed to serialize PG object (sensitive parameter, stacktrace hidden)");
} else {
LOG.error("Failed to serialize PG object", ex);
}
}
}
return result;
}
@Override
public Integer create(RentalInformation rentalInfo) {
String insertSQL = "insert into carrental.\"rentalinformation\" values (?,?,?,?)";
try {
PreparedStatement preparedStatement = connection.prepareStatement(insertSQL);
Integer refID = getNextSequenceValue();
preparedStatement.setInt(1, refID);
preparedStatement.setString(2, rentalInfo.getRentersName());
preparedStatement.setInt(3, rentalInfo.getRentersAge());
String jsonRentalDetail = convertObjectToJsonString(rentalInfo.getRentalDetail());
PGobject jsonObject = new PGobject();
jsonObject.setType("json");
jsonObject.setValue(jsonRentalDetail);
preparedStatement.setObject(4, jsonObject);
System.out.println("preparedStatement := " + preparedStatement);
preparedStatement.executeUpdate();
return refID;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
@Override
public boolean exists(org.revenj.patterns.Specification<gen.model.test.Clicked> specification) {
final String selectType = "SELECT exists(SELECT *";
java.util.function.Consumer<java.sql.PreparedStatement> applyFilters = ps -> {};
java.sql.Connection connection = getConnection();
try (org.revenj.postgres.PostgresWriter pgWriter =
org.revenj.postgres.PostgresWriter.create()) {
String sql = null;
if (specification == null) {
sql = "SELECT exists(SELECT * FROM \"test\".\"Clicked_event\" r";
} else if (specification instanceof gen.model.test.Clicked.BetweenNumbers) {
gen.model.test.Clicked.BetweenNumbers spec =
(gen.model.test.Clicked.BetweenNumbers) specification;
sql = selectType + " FROM \"test\".\"Clicked.BetweenNumbers\"(?, ?, ?) it";
applyFilters =
applyFilters.andThen(
ps -> {
try {
ps.setBigDecimal(1, spec.getMin());
} catch (Exception e) {
throw new RuntimeException(e);
}
});
applyFilters =
applyFilters.andThen(
ps -> {
try {
Object[] __arr = new Object[spec.getInSet().size()];
int __ind = 0;
for (Object __it : spec.getInSet()) __arr[__ind++] = __it;
ps.setArray(2, connection.createArrayOf("numeric", __arr));
} catch (Exception e) {
throw new RuntimeException(e);
}
});
applyFilters =
applyFilters.andThen(
ps -> {
try {
if (spec.getEn() == null) ps.setNull(3, java.sql.Types.OTHER);
else {
org.postgresql.util.PGobject __pgo = new org.postgresql.util.PGobject();
__pgo.setType("\"test\".\"En\"");
__pgo.setValue(
gen.model.test.converters.EnConverter.stringValue(spec.getEn()));
ps.setObject(3, __pgo);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
});
} else {
try {
return query(specification).any();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
try (java.sql.PreparedStatement statement = connection.prepareStatement(sql + ")")) {
applyFilters.accept(statement);
try (java.sql.ResultSet rs = statement.executeQuery()) {
rs.next();
return rs.getBoolean(1);
}
} catch (java.sql.SQLException e) {
throw new RuntimeException(e);
}
} finally {
releaseConnection(connection);
}
}
