public
/
openhab-addons
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[jdbc] Improve error handling safety (#13726) 

* Wrap YankSQLException into checked exception for all Yank calls

* Move files into internal

Signed-off-by: Jacob Laursen <jacob-github@vindvejr.dk>
This commit is contained in:
Jacob Laursen 2022-11-16 09:28:46 +01:00 committed by GitHub
parent dff4d3b4fb
commit 0873dd3ddf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 435 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/ItemTableCheckEntry.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/ItemTableCheckEntry.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc;
package org.openhab.persistence.jdbc.internal;
import org.eclipse.jdt.annotation.NonNullByDefault;

2
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/ItemTableCheckEntryStatus.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/ItemTableCheckEntryStatus.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc;
package org.openhab.persistence.jdbc.internal;
import org.eclipse.jdt.annotation.NonNullByDefault;

8
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/JdbcConfiguration.java
View File

@ -23,9 +23,9 @@ import java.util.regex.Pattern;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.persistence.jdbc.db.JdbcBaseDAO;
import org.openhab.persistence.jdbc.utils.MovingAverage;
import org.openhab.persistence.jdbc.utils.StringUtilsExt;
import org.openhab.persistence.jdbc.internal.db.JdbcBaseDAO;
import org.openhab.persistence.jdbc.internal.utils.MovingAverage;
import org.openhab.persistence.jdbc.internal.utils.StringUtilsExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -39,7 +39,7 @@ public class JdbcConfiguration {
private final Logger logger = LoggerFactory.getLogger(JdbcConfiguration.class);
private static final Pattern EXTRACT_CONFIG_PATTERN = Pattern.compile("^(.*?)\\.([0-9.a-zA-Z]+)$");
private static final String DB_DAO_PACKAGE = "org.openhab.persistence.jdbc.db.Jdbc";
private static final String DB_DAO_PACKAGE = "org.openhab.persistence.jdbc.internal.db.Jdbc";
private Map<Object, Object> configuration;

55
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/JdbcMapper.java
View File

@ -25,16 +25,16 @@ import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.knowm.yank.Yank;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.core.i18n.TimeZoneProvider;
import org.openhab.core.items.Item;
import org.openhab.core.persistence.FilterCriteria;
import org.openhab.core.persistence.HistoricItem;
import org.openhab.core.persistence.PersistenceItemInfo;
import org.openhab.core.types.State;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.dto.ItemsVO;
import org.openhab.persistence.jdbc.dto.JdbcPersistenceItemInfo;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.dto.ItemsVO;
import org.openhab.persistence.jdbc.internal.dto.JdbcPersistenceItemInfo;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -64,10 +64,10 @@ public class JdbcMapper {
this.timeZoneProvider = timeZoneProvider;
}
/*****************
/****************
* MAPPER ITEMS *
*****************/
private boolean pingDB() {
****************/
private boolean pingDB() throws JdbcSQLException {
logger.debug("JDBC::pingDB");
boolean ret = false;
long timerStart = System.currentTimeMillis();
@ -91,7 +91,7 @@ public class JdbcMapper {
return ret;
}
private boolean ifItemsTableExists() {
private boolean ifItemsTableExists() throws JdbcSQLException {
logger.debug("JDBC::ifItemsTableExists");
long timerStart = System.currentTimeMillis();
boolean res = conf.getDBDAO().doIfTableExists(new ItemsVO());
@ -99,7 +99,7 @@ public class JdbcMapper {
return res;
}
protected boolean ifTableExists(String tableName) {
protected boolean ifTableExists(String tableName) throws JdbcSQLException {
logger.debug("JDBC::ifTableExists");
long timerStart = System.currentTimeMillis();
boolean res = conf.getDBDAO().doIfTableExists(tableName);
@ -107,7 +107,7 @@ public class JdbcMapper {
return res;
}
private ItemsVO createNewEntryInItemsTable(ItemsVO vo) {
private ItemsVO createNewEntryInItemsTable(ItemsVO vo) throws JdbcSQLException {
logger.debug("JDBC::createNewEntryInItemsTable");
long timerStart = System.currentTimeMillis();
Long i = conf.getDBDAO().doCreateNewEntryInItemsTable(vo);
@ -116,7 +116,7 @@ public class JdbcMapper {
return vo;
}
private boolean createItemsTableIfNot(ItemsVO vo) {
private boolean createItemsTableIfNot(ItemsVO vo) throws JdbcSQLException {
logger.debug("JDBC::createItemsTableIfNot");
long timerStart = System.currentTimeMillis();
conf.getDBDAO().doCreateItemsTableIfNot(vo);
@ -124,7 +124,7 @@ public class JdbcMapper {
return true;
}
private boolean dropItemsTableIfExists(ItemsVO vo) {
private boolean dropItemsTableIfExists(ItemsVO vo) throws JdbcSQLException {
logger.debug("JDBC::dropItemsTableIfExists");
long timerStart = System.currentTimeMillis();
conf.getDBDAO().doDropItemsTableIfExists(vo);
@ -132,14 +132,14 @@ public class JdbcMapper {
return true;
}
protected void dropTable(String tableName) {
protected void dropTable(String tableName) throws JdbcSQLException {
logger.debug("JDBC::dropTable");
long timerStart = System.currentTimeMillis();
conf.getDBDAO().doDropTable(tableName);
logTime("doDropTable", timerStart, System.currentTimeMillis());
}
protected ItemsVO deleteItemsEntry(ItemsVO vo) {
protected ItemsVO deleteItemsEntry(ItemsVO vo) throws JdbcSQLException {
logger.debug("JDBC::deleteItemsEntry");
long timerStart = System.currentTimeMillis();
conf.getDBDAO().doDeleteItemsEntry(vo);
@ -147,7 +147,7 @@ public class JdbcMapper {
return vo;
}
private List<ItemsVO> getItemIDTableNames() {
private List<ItemsVO> getItemIDTableNames() throws JdbcSQLException {
logger.debug("JDBC::getItemIDTableNames");
long timerStart = System.currentTimeMillis();
List<ItemsVO> vo = conf.getDBDAO().doGetItemIDTableNames(new ItemsVO());
@ -155,7 +155,7 @@ public class JdbcMapper {
return vo;
}
protected List<ItemsVO> getItemTables() {
protected List<ItemsVO> getItemTables() throws JdbcSQLException {
logger.debug("JDBC::getItemTables");
long timerStart = System.currentTimeMillis();
ItemsVO vo = new ItemsVO();
@ -168,14 +168,14 @@ public class JdbcMapper {
/****************
* MAPPERS ITEM *
****************/
private void updateItemTableNames(List<ItemVO> vol) {
private void updateItemTableNames(List<ItemVO> vol) throws JdbcSQLException {
logger.debug("JDBC::updateItemTableNames");
long timerStart = System.currentTimeMillis();
conf.getDBDAO().doUpdateItemTableNames(vol);
logTime("updateItemTableNames", timerStart, System.currentTimeMillis());
}
private ItemVO createItemTable(ItemVO vo) {
private ItemVO createItemTable(ItemVO vo) throws JdbcSQLException {
logger.debug("JDBC::createItemTable");
long timerStart = System.currentTimeMillis();
conf.getDBDAO().doCreateItemTable(vo);
@ -183,7 +183,7 @@ public class JdbcMapper {
return vo;
}
protected Item storeItemValue(Item item, State itemState, @Nullable ZonedDateTime date) {
protected void storeItemValue(Item item, State itemState, @Nullable ZonedDateTime date) throws JdbcSQLException {
logger.debug("JDBC::storeItemValue: item={} state={} date={}", item, itemState, date);
String tableName = getTable(item);
long timerStart = System.currentTimeMillis();
@ -194,15 +194,14 @@ public class JdbcMapper {
}
logTime("storeItemValue", timerStart, System.currentTimeMillis());
errCnt = 0;
return item;
}
public long getRowCount(String tableName) {
public long getRowCount(String tableName) throws JdbcSQLException {
return conf.getDBDAO().doGetRowCount(tableName);
}
protected List<HistoricItem> getHistItemFilterQuery(FilterCriteria filter, int numberDecimalcount, String table,
Item item) {
Item item) throws JdbcSQLException {
logger.debug(
"JDBC::getHistItemFilterQuery filter='{}' numberDecimalcount='{}' table='{}' item='{}' itemName='{}'",
true, numberDecimalcount, table, item, item.getName());
@ -214,7 +213,7 @@ public class JdbcMapper {
return result;
}
protected void deleteItemValues(FilterCriteria filter, String table) {
protected void deleteItemValues(FilterCriteria filter, String table) throws JdbcSQLException {
logger.debug("JDBC::deleteItemValues filter='{}' table='{}' itemName='{}'", true, table, filter.getItemName());
long timerStart = System.currentTimeMillis();
conf.getDBDAO().doDeleteItemValues(filter, table, timeZoneProvider.getTimeZone());
@ -276,7 +275,7 @@ public class JdbcMapper {
logger.debug("JDBC::checkDBAcessability, second try connection: {}", p);
return (p && !(conf.getErrReconnectThreshold() > 0 && errCnt <= conf.getErrReconnectThreshold()));
}
} catch (YankSQLException e) {
} catch (JdbcSQLException e) {
logger.warn("Unable to ping database", e);
return false;
}
@ -285,7 +284,7 @@ public class JdbcMapper {
/**************************
* DATABASE TABLEHANDLING *
**************************/
protected void checkDBSchema() {
protected void checkDBSchema() throws JdbcSQLException {
if (!conf.getTableUseRealCaseSensitiveItemNames()) {
createItemsTableIfNot(new ItemsVO());
}
@ -303,7 +302,7 @@ public class JdbcMapper {
populateItemNameToTableNameMap();
}
private void populateItemNameToTableNameMap() {
private void populateItemNameToTableNameMap() throws JdbcSQLException {
itemNameToTableNameMap.clear();
if (conf.getTableUseRealCaseSensitiveItemNames()) {
for (String itemName : getItemTables().stream().map(t -> t.getTableName()).collect(Collectors.toList())) {
@ -317,7 +316,7 @@ public class JdbcMapper {
}
}
protected String getTable(Item item) {
protected String getTable(Item item) throws JdbcSQLException {
int itemId = 0;
ItemsVO isvo;
ItemVO ivo;
@ -360,7 +359,7 @@ public class JdbcMapper {
return tableName;
}
private void formatTableNames() {
private void formatTableNames() throws JdbcSQLException {
boolean tmpinit = initialized;
if (tmpinit) {
initialized = false;

24
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/JdbcPersistenceService.java
View File

@ -25,7 +25,6 @@ import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.core.config.core.ConfigurableService;
import org.openhab.core.i18n.TimeZoneProvider;
import org.openhab.core.items.GroupItem;
@ -41,9 +40,8 @@ import org.openhab.core.persistence.QueryablePersistenceService;
import org.openhab.core.persistence.strategy.PersistenceStrategy;
import org.openhab.core.types.State;
import org.openhab.core.types.UnDefType;
import org.openhab.persistence.jdbc.ItemTableCheckEntry;
import org.openhab.persistence.jdbc.ItemTableCheckEntryStatus;
import org.openhab.persistence.jdbc.dto.ItemsVO;
import org.openhab.persistence.jdbc.internal.dto.ItemsVO;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.service.component.annotations.Activate;
@ -163,7 +161,7 @@ public class JdbcPersistenceService extends JdbcMapper implements ModifiablePers
logger.debug("JDBC: Stored item '{}' as '{}' in SQL database at {} in {} ms.", item.getName(), state,
new Date(), System.currentTimeMillis() - timerStart);
}
} catch (YankSQLException e) {
} catch (JdbcSQLException e) {
logger.warn("JDBC::store: Unable to store item", e);
}
}
@ -230,7 +228,7 @@ public class JdbcPersistenceService extends JdbcMapper implements ModifiablePers
// Success
errCnt = 0;
return items;
} catch (YankSQLException e) {
} catch (JdbcSQLException e) {
logger.warn("JDBC::query: Unable to query item", e);
return List.of();
}
@ -246,7 +244,7 @@ public class JdbcPersistenceService extends JdbcMapper implements ModifiablePers
checkDBSchema();
// connection has been established ... initialization completed!
initialized = true;
} catch (YankSQLException e) {
} catch (JdbcSQLException e) {
logger.error("Failed to check database schema", e);
initialized = false;
}
@ -291,7 +289,7 @@ public class JdbcPersistenceService extends JdbcMapper implements ModifiablePers
System.currentTimeMillis() - timerStart);
}
return true;
} catch (YankSQLException e) {
} catch (JdbcSQLException e) {
logger.debug("JDBC::remove: Unable to remove values for item", e);
return false;
}
@ -310,7 +308,7 @@ public class JdbcPersistenceService extends JdbcMapper implements ModifiablePers
*
* @return list of {@link ItemTableCheckEntry}
*/
public List<ItemTableCheckEntry> getCheckedEntries() {
public List<ItemTableCheckEntry> getCheckedEntries() throws JdbcSQLException {
List<ItemTableCheckEntry> entries = new ArrayList<>();
if (!checkDBAccessability()) {
@ -362,8 +360,9 @@ public class JdbcPersistenceService extends JdbcMapper implements ModifiablePers
* @param itemName Name of item to clean
* @param force If true, non-empty tables will be dropped too
* @return true if item was cleaned up
* @throws JdbcSQLException
*/
public boolean cleanupItem(String itemName, boolean force) {
public boolean cleanupItem(String itemName, boolean force) throws JdbcSQLException {
String tableName = itemNameToTableNameMap.get(itemName);
if (tableName == null) {
return false;
@ -378,12 +377,13 @@ public class JdbcPersistenceService extends JdbcMapper implements ModifiablePers
*
* @param entry
* @return true if item was cleaned up
* @throws JdbcSQLException
*/
public boolean cleanupItem(ItemTableCheckEntry entry) {
public boolean cleanupItem(ItemTableCheckEntry entry) throws JdbcSQLException {
return cleanupItem(entry, false);
}
private boolean cleanupItem(ItemTableCheckEntry entry, boolean force) {
private boolean cleanupItem(ItemTableCheckEntry entry, boolean force) throws JdbcSQLException {
if (!checkDBAccessability()) {
logger.warn("JDBC::cleanupItem: database not connected");
return false;

2
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/NamingStrategy.java
View File

@ -21,7 +21,7 @@ import java.util.Objects;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.core.items.ItemUtil;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

22
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/console/JdbcCommandExtension.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/console/JdbcCommandExtension.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.console;
package org.openhab.persistence.jdbc.internal.console;
import java.util.Arrays;
import java.util.Comparator;
@ -19,7 +19,6 @@ import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.core.io.console.Console;
import org.openhab.core.io.console.ConsoleCommandCompleter;
import org.openhab.core.io.console.StringsCompleter;
@ -27,10 +26,11 @@ import org.openhab.core.io.console.extensions.AbstractConsoleCommandExtension;
import org.openhab.core.io.console.extensions.ConsoleCommandExtension;
import org.openhab.core.persistence.PersistenceService;
import org.openhab.core.persistence.PersistenceServiceRegistry;
import org.openhab.persistence.jdbc.ItemTableCheckEntry;
import org.openhab.persistence.jdbc.ItemTableCheckEntryStatus;
import org.openhab.persistence.jdbc.internal.ItemTableCheckEntry;
import org.openhab.persistence.jdbc.internal.ItemTableCheckEntryStatus;
import org.openhab.persistence.jdbc.internal.JdbcPersistenceService;
import org.openhab.persistence.jdbc.internal.JdbcPersistenceServiceConstants;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;
@ -76,7 +76,7 @@ public class JdbcCommandExtension extends AbstractConsoleCommandExtension implem
printUsage(console);
return;
}
} catch (YankSQLException e) {
} catch (JdbcSQLException e) {
console.println(e.toString());
}
}
@ -90,7 +90,8 @@ public class JdbcCommandExtension extends AbstractConsoleCommandExtension implem
return null;
}
private boolean execute(JdbcPersistenceService persistenceService, String[] args, Console console) {
private boolean execute(JdbcPersistenceService persistenceService, String[] args, Console console)
throws JdbcSQLException {
if (SUBCMD_TABLES_LIST.equalsIgnoreCase(args[1])) {
listTables(persistenceService, console, args.length == 3 && PARAMETER_ALL.equalsIgnoreCase(args[2]));
return true;
@ -109,7 +110,8 @@ public class JdbcCommandExtension extends AbstractConsoleCommandExtension implem
return false;
}
private void listTables(JdbcPersistenceService persistenceService, Console console, Boolean all) {
private void listTables(JdbcPersistenceService persistenceService, Console console, Boolean all)
throws JdbcSQLException {
List<ItemTableCheckEntry> entries = persistenceService.getCheckedEntries();
if (!all) {
entries.removeIf(t -> t.getStatus() == ItemTableCheckEntryStatus.VALID);
@ -138,7 +140,7 @@ public class JdbcCommandExtension extends AbstractConsoleCommandExtension implem
}
}
private void cleanupTables(JdbcPersistenceService persistenceService, Console console) {
private void cleanupTables(JdbcPersistenceService persistenceService, Console console) throws JdbcSQLException {
console.println("Cleaning up all inconsistent items...");
List<ItemTableCheckEntry> entries = persistenceService.getCheckedEntries();
entries.removeIf(t -> t.getStatus() == ItemTableCheckEntryStatus.VALID || t.getItemName().isEmpty());
@ -152,8 +154,8 @@ public class JdbcCommandExtension extends AbstractConsoleCommandExtension implem
}
}
private void cleanupItem(JdbcPersistenceService persistenceService, Console console, String itemName,
boolean force) {
private void cleanupItem(JdbcPersistenceService persistenceService, Console console, String itemName, boolean force)
throws JdbcSQLException {
console.print("Cleaning up item " + itemName + "... ");
if (persistenceService.cleanupItem(itemName, force)) {
console.println("done.");

169
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/db/JdbcBaseDAO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/db/JdbcBaseDAO.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import java.math.BigDecimal;
import java.time.Instant;
@ -32,6 +32,7 @@ import javax.measure.Unit;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.knowm.yank.Yank;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.core.items.GroupItem;
import org.openhab.core.items.Item;
import org.openhab.core.library.items.ColorItem;
@ -55,11 +56,12 @@ import org.openhab.core.persistence.FilterCriteria.Ordering;
import org.openhab.core.persistence.HistoricItem;
import org.openhab.core.types.State;
import org.openhab.core.types.TypeParser;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.dto.ItemsVO;
import org.openhab.persistence.jdbc.dto.JdbcHistoricItem;
import org.openhab.persistence.jdbc.utils.DbMetaData;
import org.openhab.persistence.jdbc.utils.StringUtilsExt;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.dto.ItemsVO;
import org.openhab.persistence.jdbc.internal.dto.JdbcHistoricItem;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.openhab.persistence.jdbc.internal.utils.DbMetaData;
import org.openhab.persistence.jdbc.internal.utils.StringUtilsExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -248,131 +250,196 @@ public class JdbcBaseDAO {
/**************
* ITEMS DAOs *
**************/
public @Nullable Integer doPingDB() {
final @Nullable Integer result = Yank.queryScalar(sqlPingDB, Integer.class, null);
return result;
public @Nullable Integer doPingDB() throws JdbcSQLException {
try {
final @Nullable Integer result = Yank.queryScalar(sqlPingDB, Integer.class, null);
return result;
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public @Nullable String doGetDB() {
final @Nullable String result = Yank.queryScalar(sqlGetDB, String.class, null);
return result;
public @Nullable String doGetDB() throws JdbcSQLException {
try {
final @Nullable String result = Yank.queryScalar(sqlGetDB, String.class, null);
return result;
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public boolean doIfTableExists(ItemsVO vo) {
public boolean doIfTableExists(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlIfTableExists, new String[] { "#searchTable#" },
new String[] { vo.getItemsManageTable() });
logger.debug("JDBC::doIfTableExists sql={}", sql);
final @Nullable String result = Yank.queryScalar(sql, String.class, null);
return Objects.nonNull(result);
try {
final @Nullable String result = Yank.queryScalar(sql, String.class, null);
return Objects.nonNull(result);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public boolean doIfTableExists(String tableName) {
public boolean doIfTableExists(String tableName) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlIfTableExists, new String[] { "#searchTable#" },
new String[] { tableName });
logger.debug("JDBC::doIfTableExists sql={}", sql);
final @Nullable String result = Yank.queryScalar(sql, String.class, null);
return Objects.nonNull(result);
try {
final @Nullable String result = Yank.queryScalar(sql, String.class, null);
return Objects.nonNull(result);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public Long doCreateNewEntryInItemsTable(ItemsVO vo) {
public Long doCreateNewEntryInItemsTable(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateNewEntryInItemsTable,
new String[] { "#itemsManageTable#", "#itemname#" },
new String[] { vo.getItemsManageTable(), vo.getItemName() });
logger.debug("JDBC::doCreateNewEntryInItemsTable sql={}", sql);
return Yank.insert(sql, null);
try {
return Yank.insert(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) {
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateItemsTableIfNot,
new String[] { "#itemsManageTable#", "#colname#", "#coltype#" },
new String[] { vo.getItemsManageTable(), vo.getColname(), vo.getColtype() });
logger.debug("JDBC::doCreateItemsTableIfNot sql={}", sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
return vo;
}
public ItemsVO doDropItemsTableIfExists(ItemsVO vo) {
public ItemsVO doDropItemsTableIfExists(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlDropItemsTableIfExists, new String[] { "#itemsManageTable#" },
new String[] { vo.getItemsManageTable() });
logger.debug("JDBC::doDropItemsTableIfExists sql={}", sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
return vo;
}
public void doDropTable(String tableName) {
public void doDropTable(String tableName) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlDropTable, new String[] { "#tableName#" },
new String[] { tableName });
logger.debug("JDBC::doDropTable sql={}", sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public void doDeleteItemsEntry(ItemsVO vo) {
public void doDeleteItemsEntry(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlDeleteItemsEntry,
new String[] { "#itemsManageTable#", "#itemname#" },
new String[] { vo.getItemsManageTable(), vo.getItemName() });
logger.debug("JDBC::doDeleteItemsEntry sql={}", sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public List<ItemsVO> doGetItemIDTableNames(ItemsVO vo) {
public List<ItemsVO> doGetItemIDTableNames(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlGetItemIDTableNames, new String[] { "#itemsManageTable#" },
new String[] { vo.getItemsManageTable() });
logger.debug("JDBC::doGetItemIDTableNames sql={}", sql);
return Yank.queryBeanList(sql, ItemsVO.class, null);
try {
return Yank.queryBeanList(sql, ItemsVO.class, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public List<ItemsVO> doGetItemTables(ItemsVO vo) {
public List<ItemsVO> doGetItemTables(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlGetItemTables,
new String[] { "#jdbcUriDatabaseName#", "#itemsManageTable#" },
new String[] { vo.getJdbcUriDatabaseName(), vo.getItemsManageTable() });
logger.debug("JDBC::doGetItemTables sql={}", sql);
return Yank.queryBeanList(sql, ItemsVO.class, null);
try {
return Yank.queryBeanList(sql, ItemsVO.class, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/*************
* ITEM DAOs *
*************/
public void doUpdateItemTableNames(List<ItemVO> vol) {
public void doUpdateItemTableNames(List<ItemVO> vol) throws JdbcSQLException {
logger.debug("JDBC::doUpdateItemTableNames vol.size = {}", vol.size());
for (ItemVO itemTable : vol) {
String sql = updateItemTableNamesProvider(itemTable);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
}
public void doCreateItemTable(ItemVO vo) {
public void doCreateItemTable(ItemVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateItemTable,
new String[] { "#tableName#", "#dbType#", "#tablePrimaryKey#" },
new String[] { vo.getTableName(), vo.getDbType(), sqlTypes.get("tablePrimaryKey") });
logger.debug("JDBC::doCreateItemTable sql={}", sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public void doStoreItemValue(Item item, State itemState, ItemVO vo) {
public void doStoreItemValue(Item item, State itemState, ItemVO vo) throws JdbcSQLException {
ItemVO storedVO = storeItemValueProvider(item, itemState, vo);
String sql = StringUtilsExt.replaceArrayMerge(sqlInsertItemValue,
new String[] { "#tableName#", "#tablePrimaryValue#" },
new String[] { storedVO.getTableName(), sqlTypes.get("tablePrimaryValue") });
Object[] params = { storedVO.getValue(), storedVO.getValue() };
logger.debug("JDBC::doStoreItemValue sql={} value='{}'", sql, storedVO.getValue());
Yank.execute(sql, params);
try {
Yank.execute(sql, params);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public void doStoreItemValue(Item item, State itemState, ItemVO vo, ZonedDateTime date) {
public void doStoreItemValue(Item item, State itemState, ItemVO vo, ZonedDateTime date) throws JdbcSQLException {
ItemVO storedVO = storeItemValueProvider(item, itemState, vo);
String sql = StringUtilsExt.replaceArrayMerge(sqlInsertItemValue,
new String[] { "#tableName#", "#tablePrimaryValue#" }, new String[] { storedVO.getTableName(), "?" });
java.sql.Timestamp timestamp = new java.sql.Timestamp(date.toInstant().toEpochMilli());
Object[] params = { timestamp, storedVO.getValue(), storedVO.getValue() };
logger.debug("JDBC::doStoreItemValue sql={} timestamp={} value='{}'", sql, timestamp, storedVO.getValue());
Yank.execute(sql, params);
try {
Yank.execute(sql, params);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public List<HistoricItem> doGetHistItemFilterQuery(Item item, FilterCriteria filter, int numberDecimalcount,
String table, String name, ZoneId timeZone) {
String table, String name, ZoneId timeZone) throws JdbcSQLException {
String sql = histItemFilterQueryProvider(filter, numberDecimalcount, table, name, timeZone);
logger.debug("JDBC::doGetHistItemFilterQuery sql={}", sql);
List<Object[]> m = Yank.queryObjectArrays(sql, null);
List<Object[]> m;
try {
m = Yank.queryObjectArrays(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
if (m == null) {
logger.debug("JDBC::doGetHistItemFilterQuery Query failed. Returning an empty list.");
return List.of();
@ -385,18 +452,26 @@ public class JdbcBaseDAO {
.collect(Collectors.<HistoricItem> toList());
}
public void doDeleteItemValues(FilterCriteria filter, String table, ZoneId timeZone) {
public void doDeleteItemValues(FilterCriteria filter, String table, ZoneId timeZone) throws JdbcSQLException {
String sql = histItemFilterDeleteProvider(filter, table, timeZone);
logger.debug("JDBC::doDeleteItemValues sql={}", sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
public long doGetRowCount(String tableName) {
public long doGetRowCount(String tableName) throws JdbcSQLException {
final String sql = StringUtilsExt.replaceArrayMerge(sqlGetRowCount, new String[] { "#tableName#" },
new String[] { tableName });
logger.debug("JDBC::doGetRowCount sql={}", sql);
final @Nullable Long result = Yank.queryScalar(sql, Long.class, null);
return Objects.requireNonNullElse(result, 0L);
try {
final @Nullable Long result = Yank.queryScalar(sql, Long.class, null);
return Objects.requireNonNullElse(result, 0L);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/*************

73
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/db/JdbcDerbyDAO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/db/JdbcDerbyDAO.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import java.time.ZoneId;
import java.util.List;
@ -23,16 +23,18 @@ import javax.measure.Unit;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.knowm.yank.Yank;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.core.items.Item;
import org.openhab.core.library.items.NumberItem;
import org.openhab.core.persistence.FilterCriteria;
import org.openhab.core.persistence.FilterCriteria.Ordering;
import org.openhab.core.persistence.HistoricItem;
import org.openhab.core.types.State;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.dto.ItemsVO;
import org.openhab.persistence.jdbc.dto.JdbcHistoricItem;
import org.openhab.persistence.jdbc.utils.StringUtilsExt;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.dto.ItemsVO;
import org.openhab.persistence.jdbc.internal.dto.JdbcHistoricItem;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.openhab.persistence.jdbc.internal.utils.StringUtilsExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -106,39 +108,53 @@ public class JdbcDerbyDAO extends JdbcBaseDAO {
* ITEMS DAOs *
**************/
@Override
public @Nullable Integer doPingDB() {
return Yank.queryScalar(sqlPingDB, Integer.class, null);
public @Nullable Integer doPingDB() throws JdbcSQLException {
try {
return Yank.queryScalar(sqlPingDB, Integer.class, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
@Override
public boolean doIfTableExists(ItemsVO vo) {
public boolean doIfTableExists(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlIfTableExists, new String[] { "#searchTable#" },
new String[] { vo.getItemsManageTable().toUpperCase() });
logger.debug("JDBC::doIfTableExists sql={}", sql);
final @Nullable String result = Yank.queryScalar(sql, String.class, null);
return Objects.nonNull(result);
try {
final @Nullable String result = Yank.queryScalar(sql, String.class, null);
return Objects.nonNull(result);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
@Override
public Long doCreateNewEntryInItemsTable(ItemsVO vo) {
public Long doCreateNewEntryInItemsTable(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateNewEntryInItemsTable,
new String[] { "#itemsManageTable#", "#itemname#" },
new String[] { vo.getItemsManageTable().toUpperCase(), vo.getItemName() });
logger.debug("JDBC::doCreateNewEntryInItemsTable sql={}", sql);
return Yank.insert(sql, null);
try {
return Yank.insert(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
@Override
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) {
// boolean tableExists = Yank.queryScalar(SQL_IF_TABLE_EXISTS.replace("#searchTable#",
// vo.getItemsManageTable().toUpperCase()), String.class, null) == null;
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) throws JdbcSQLException {
boolean tableExists = doIfTableExists(vo);
if (!tableExists) {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateItemsTableIfNot,
new String[] { "#itemsManageTable#", "#colname#", "#coltype#" },
new String[] { vo.getItemsManageTable().toUpperCase(), vo.getColname(), vo.getColtype() });
logger.debug("JDBC::doCreateItemsTableIfNot tableExists={} therefore sql={}", tableExists, sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
} else {
logger.debug("JDBC::doCreateItemsTableIfNot tableExists={}, did not CREATE TABLE", tableExists);
}
@ -149,15 +165,19 @@ public class JdbcDerbyDAO extends JdbcBaseDAO {
* ITEM DAOs *
*************/
@Override
public void doCreateItemTable(ItemVO vo) {
public void doCreateItemTable(ItemVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateItemTable,
new String[] { "#tableName#", "#dbType#", "#tablePrimaryKey#" },
new String[] { vo.getTableName(), vo.getDbType(), sqlTypes.get("tablePrimaryKey") });
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
@Override
public void doStoreItemValue(Item item, State itemState, ItemVO vo) {
public void doStoreItemValue(Item item, State itemState, ItemVO vo) throws JdbcSQLException {
ItemVO storedVO = storeItemValueProvider(item, itemState, vo);
String sql = StringUtilsExt.replaceArrayMerge(sqlInsertItemValue,
new String[] { "#tableName#", "#dbType#", "#tablePrimaryValue#" },
@ -165,14 +185,23 @@ public class JdbcDerbyDAO extends JdbcBaseDAO {
sqlTypes.get("tablePrimaryValue") });
Object[] params = { storedVO.getValue() };
logger.debug("JDBC::doStoreItemValue sql={} value='{}'", sql, storedVO.getValue());
Yank.execute(sql, params);
try {
Yank.execute(sql, params);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
@Override
public List<HistoricItem> doGetHistItemFilterQuery(Item item, FilterCriteria filter, int numberDecimalcount,
String table, String name, ZoneId timeZone) {
String table, String name, ZoneId timeZone) throws JdbcSQLException {
String sql = histItemFilterQueryProvider(filter, numberDecimalcount, table, name, timeZone);
List<Object[]> m = Yank.queryObjectArrays(sql, null);
List<Object[]> m;
try {
m = Yank.queryObjectArrays(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
logger.debug("JDBC::doGetHistItemFilterQuery got Array length={}", m.size());
// we already retrieve the unit here once as it is a very costly operation
String itemName = item.getName();

16
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/db/JdbcH2DAO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/db/JdbcH2DAO.java
View File

@ -10,14 +10,16 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.knowm.yank.Yank;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.core.items.Item;
import org.openhab.core.types.State;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.utils.StringUtilsExt;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.openhab.persistence.jdbc.internal.utils.StringUtilsExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -77,14 +79,18 @@ public class JdbcH2DAO extends JdbcBaseDAO {
* ITEM DAOs *
*************/
@Override
public void doStoreItemValue(Item item, State itemState, ItemVO vo) {
public void doStoreItemValue(Item item, State itemState, ItemVO vo) throws JdbcSQLException {
ItemVO storedVO = storeItemValueProvider(item, itemState, vo);
String sql = StringUtilsExt.replaceArrayMerge(sqlInsertItemValue,
new String[] { "#tableName#", "#dbType#", "#tablePrimaryValue#" },
new String[] { storedVO.getTableName(), storedVO.getDbType(), sqlTypes.get("tablePrimaryValue") });
Object[] params = { storedVO.getValue() };
logger.debug("JDBC::doStoreItemValue sql={} value='{}'", sql, storedVO.getValue());
Yank.execute(sql, params);
try {
Yank.execute(sql, params);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/****************************

42
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/db/JdbcHsqldbDAO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/db/JdbcHsqldbDAO.java
View File

@ -10,16 +10,18 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.knowm.yank.Yank;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.core.items.Item;
import org.openhab.core.types.State;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.dto.ItemsVO;
import org.openhab.persistence.jdbc.utils.StringUtilsExt;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.dto.ItemsVO;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.openhab.persistence.jdbc.internal.utils.StringUtilsExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -83,34 +85,46 @@ public class JdbcHsqldbDAO extends JdbcBaseDAO {
* ITEMS DAOs *
**************/
@Override
public @Nullable Integer doPingDB() {
return Yank.queryScalar(sqlPingDB, Integer.class, null);
public @Nullable Integer doPingDB() throws JdbcSQLException {
try {
return Yank.queryScalar(sqlPingDB, Integer.class, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
@Override
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) {
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateItemsTableIfNot,
new String[] { "#itemsManageTable#", "#colname#", "#coltype#", "#itemsManageTable#" },
new String[] { vo.getItemsManageTable(), vo.getColname(), vo.getColtype(), vo.getItemsManageTable() });
logger.debug("JDBC::doCreateItemsTableIfNot sql={}", sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
return vo;
}
@Override
public Long doCreateNewEntryInItemsTable(ItemsVO vo) {
public Long doCreateNewEntryInItemsTable(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateNewEntryInItemsTable,
new String[] { "#itemsManageTable#", "#itemname#" },
new String[] { vo.getItemsManageTable(), vo.getItemName() });
logger.debug("JDBC::doCreateNewEntryInItemsTable sql={}", sql);
return Yank.insert(sql, null);
try {
return Yank.insert(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/*************
* ITEM DAOs *
*************/
@Override
public void doStoreItemValue(Item item, State itemState, ItemVO vo) {
public void doStoreItemValue(Item item, State itemState, ItemVO vo) throws JdbcSQLException {
ItemVO storedVO = storeItemValueProvider(item, itemState, vo);
String sql = StringUtilsExt.replaceArrayMerge(sqlInsertItemValue,
new String[] { "#tableName#", "#dbType#", "#tableName#", "#tablePrimaryValue#" },
@ -118,7 +132,11 @@ public class JdbcHsqldbDAO extends JdbcBaseDAO {
sqlTypes.get("tablePrimaryValue") });
Object[] params = { storedVO.getValue() };
logger.debug("JDBC::doStoreItemValue sql={} value='{}'", sql, storedVO.getValue());
Yank.execute(sql, params);
try {
Yank.execute(sql, params);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/****************************

16
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/db/JdbcMariadbDAO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/db/JdbcMariadbDAO.java
View File

@ -10,14 +10,16 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import java.util.Objects;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.knowm.yank.Yank;
import org.openhab.persistence.jdbc.utils.DbMetaData;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.openhab.persistence.jdbc.internal.utils.DbMetaData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -95,9 +97,13 @@ public class JdbcMariadbDAO extends JdbcBaseDAO {
* ITEMS DAOs *
**************/
@Override
public @Nullable Integer doPingDB() {
final @Nullable Long result = Yank.queryScalar(sqlPingDB, Long.class, null);
return Objects.nonNull(result) ? result.intValue() : null;
public @Nullable Integer doPingDB() throws JdbcSQLException {
try {
final @Nullable Long result = Yank.queryScalar(sqlPingDB, Long.class, null);
return Objects.nonNull(result) ? result.intValue() : null;
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/*************

16
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/db/JdbcMysqlDAO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/db/JdbcMysqlDAO.java
View File

@ -10,14 +10,16 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import java.util.Objects;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.knowm.yank.Yank;
import org.openhab.persistence.jdbc.utils.DbMetaData;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.openhab.persistence.jdbc.internal.utils.DbMetaData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -98,9 +100,13 @@ public class JdbcMysqlDAO extends JdbcBaseDAO {
* ITEMS DAOs *
**************/
@Override
public @Nullable Integer doPingDB() {
final @Nullable Long result = Yank.queryScalar(sqlPingDB, Long.class, null);
return Objects.nonNull(result) ? result.intValue() : null;
public @Nullable Integer doPingDB() throws JdbcSQLException {
try {
final @Nullable Long result = Yank.queryScalar(sqlPingDB, Long.class, null);
return Objects.nonNull(result) ? result.intValue() : null;
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/*************

42
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/db/JdbcPostgresqlDAO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/db/JdbcPostgresqlDAO.java
View File

@ -10,20 +10,22 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import java.time.ZoneId;
import java.util.List;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.knowm.yank.Yank;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.core.items.Item;
import org.openhab.core.persistence.FilterCriteria;
import org.openhab.core.persistence.FilterCriteria.Ordering;
import org.openhab.core.types.State;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.dto.ItemsVO;
import org.openhab.persistence.jdbc.utils.StringUtilsExt;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.dto.ItemsVO;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.openhab.persistence.jdbc.internal.utils.StringUtilsExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -108,45 +110,61 @@ public class JdbcPostgresqlDAO extends JdbcBaseDAO {
* ITEMS DAOs *
**************/
@Override
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) {
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateItemsTableIfNot,
new String[] { "#itemsManageTable#", "#colname#", "#coltype#", "#itemsManageTable#" },
new String[] { vo.getItemsManageTable(), vo.getColname(), vo.getColtype(), vo.getItemsManageTable() });
logger.debug("JDBC::doCreateItemsTableIfNot sql={}", sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
return vo;
}
@Override
public Long doCreateNewEntryInItemsTable(ItemsVO vo) {
public Long doCreateNewEntryInItemsTable(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateNewEntryInItemsTable,
new String[] { "#itemsManageTable#", "#itemname#" },
new String[] { vo.getItemsManageTable(), vo.getItemName() });
logger.debug("JDBC::doCreateNewEntryInItemsTable sql={}", sql);
return Yank.insert(sql, null);
try {
return Yank.insert(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
@Override
public List<ItemsVO> doGetItemTables(ItemsVO vo) {
public List<ItemsVO> doGetItemTables(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(this.sqlGetItemTables,
new String[] { "#itemsManageTable#", "#itemsManageTable#" },
new String[] { vo.getItemsManageTable(), vo.getItemsManageTable() });
this.logger.debug("JDBC::doGetItemTables sql={}", sql);
return Yank.queryBeanList(sql, ItemsVO.class, null);
try {
return Yank.queryBeanList(sql, ItemsVO.class, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/*************
* ITEM DAOs *
*************/
@Override
public void doStoreItemValue(Item item, State itemState, ItemVO vo) {
public void doStoreItemValue(Item item, State itemState, ItemVO vo) throws JdbcSQLException {
ItemVO storedVO = storeItemValueProvider(item, itemState, vo);
String sql = StringUtilsExt.replaceArrayMerge(sqlInsertItemValue,
new String[] { "#tableName#", "#dbType#", "#tablePrimaryValue#" },
new String[] { storedVO.getTableName(), storedVO.getDbType(), sqlTypes.get("tablePrimaryValue") });
Object[] params = { storedVO.getValue() };
logger.debug("JDBC::doStoreItemValue sql={} value='{}'", sql, storedVO.getValue());
Yank.execute(sql, params);
try {
Yank.execute(sql, params);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/****************************

34
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/db/JdbcSqliteDAO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/db/JdbcSqliteDAO.java
View File

@ -10,16 +10,18 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.knowm.yank.Yank;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.core.items.Item;
import org.openhab.core.types.State;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.dto.ItemsVO;
import org.openhab.persistence.jdbc.utils.StringUtilsExt;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.dto.ItemsVO;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.openhab.persistence.jdbc.internal.utils.StringUtilsExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -79,17 +81,25 @@ public class JdbcSqliteDAO extends JdbcBaseDAO {
**************/
@Override
public @Nullable String doGetDB() {
return Yank.queryColumn(sqlGetDB, "file", String.class, null).get(0);
public @Nullable String doGetDB() throws JdbcSQLException {
try {
return Yank.queryColumn(sqlGetDB, "file", String.class, null).get(0);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
@Override
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) {
public ItemsVO doCreateItemsTableIfNot(ItemsVO vo) throws JdbcSQLException {
String sql = StringUtilsExt.replaceArrayMerge(sqlCreateItemsTableIfNot,
new String[] { "#itemsManageTable#", "#colname#", "#coltype#" },
new String[] { vo.getItemsManageTable(), vo.getColname(), vo.getColtype() });
logger.debug("JDBC::doCreateItemsTableIfNot sql={}", sql);
Yank.execute(sql, null);
try {
Yank.execute(sql, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
return vo;
}
@ -97,14 +107,18 @@ public class JdbcSqliteDAO extends JdbcBaseDAO {
* ITEM DAOs *
*************/
@Override
public void doStoreItemValue(Item item, State itemState, ItemVO vo) {
public void doStoreItemValue(Item item, State itemState, ItemVO vo) throws JdbcSQLException {
ItemVO storedVO = storeItemValueProvider(item, itemState, vo);
String sql = StringUtilsExt.replaceArrayMerge(sqlInsertItemValue,
new String[] { "#tableName#", "#dbType#", "#tablePrimaryValue#" },
new String[] { storedVO.getTableName(), storedVO.getDbType(), sqlTypes.get("tablePrimaryValue") });
Object[] params = { storedVO.getValue() };
logger.debug("JDBC::doStoreItemValue sql={} value='{}'", sql, storedVO.getValue());
Yank.execute(sql, params);
try {
Yank.execute(sql, params);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
/****************************

16
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/db/JdbcTimescaledbDAO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/db/JdbcTimescaledbDAO.java
View File

@ -10,14 +10,16 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import java.util.Properties;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.knowm.yank.Yank;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.utils.StringUtilsExt;
import org.knowm.yank.exceptions.YankSQLException;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.exceptions.JdbcSQLException;
import org.openhab.persistence.jdbc.internal.utils.StringUtilsExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -45,11 +47,15 @@ public class JdbcTimescaledbDAO extends JdbcPostgresqlDAO {
}
@Override
public void doCreateItemTable(ItemVO vo) {
public void doCreateItemTable(ItemVO vo) throws JdbcSQLException {
super.doCreateItemTable(vo);
String sql = StringUtilsExt.replaceArrayMerge(this.sqlCreateHypertable, new String[] { "#tableName#" },
new String[] { vo.getTableName() });
this.logger.debug("JDBC::doCreateItemTable sql={}", sql);
Yank.queryScalar(sql, Boolean.class, null);
try {
Yank.queryScalar(sql, Boolean.class, null);
} catch (YankSQLException e) {
throw new JdbcSQLException(e);
}
}
}

2
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/dto/ItemVO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/dto/ItemVO.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.dto;
package org.openhab.persistence.jdbc.internal.dto;
import java.io.Serializable;
import java.util.Date;

2
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/dto/ItemsVO.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/dto/ItemsVO.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.dto;
package org.openhab.persistence.jdbc.internal.dto;
import java.io.Serializable;
import java.util.Objects;

2
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/dto/JdbcHistoricItem.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/dto/JdbcHistoricItem.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.dto;
package org.openhab.persistence.jdbc.internal.dto;
import java.time.ZonedDateTime;

2
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/dto/JdbcPersistenceItemInfo.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/dto/JdbcPersistenceItemInfo.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.dto;
package org.openhab.persistence.jdbc.internal.dto;
import java.util.Date;

34
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/exceptions/JdbcException.java Normal file
View File

@ -0,0 +1,34 @@
/**
* Copyright (c) 2010-2022 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.internal.exceptions;
import org.eclipse.jdt.annotation.NonNullByDefault;
/**
* Base class for JDBC exceptions.
*
* @author Jacob Laursen - Initial contribution
*/
@NonNullByDefault
public class JdbcException extends Exception {
private static final long serialVersionUID = 1911437557128995424L;
public JdbcException(String message) {
super(message);
}
public JdbcException(String message, Throwable cause) {
super(message, cause);
}
}

33
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/exceptions/JdbcSQLException.java Normal file
View File

@ -0,0 +1,33 @@
/**
* Copyright (c) 2010-2022 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.internal.exceptions;
import java.util.Objects;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.knowm.yank.exceptions.YankSQLException;
/**
* This exception wraps a {@link YankSQLException}.
*
* @author Jacob Laursen - Initial contribution
*/
@NonNullByDefault
public class JdbcSQLException extends JdbcException {
private static final long serialVersionUID = 4562191548585905000L;
public JdbcSQLException(YankSQLException sqlException) {
super(Objects.requireNonNull(sqlException.getMessage()));
}
}

3
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/utils/DbMetaData.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/utils/DbMetaData.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.utils;
package org.openhab.persistence.jdbc.internal.utils;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
@ -42,7 +42,6 @@ public class DbMetaData {
public DbMetaData() {
HikariDataSource h = Yank.getDefaultConnectionPool();
// HikariDataSource h = Yank.getDataSource();
DatabaseMetaData meta;
try {

2
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/utils/MovingAverage.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/utils/MovingAverage.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.utils;
package org.openhab.persistence.jdbc.internal.utils;
import java.math.BigDecimal;
import java.math.RoundingMode;

2
bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/utils/StringUtilsExt.java → bundles/org.openhab.persistence.jdbc/src/main/java/org/openhab/persistence/jdbc/internal/utils/StringUtilsExt.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.utils;
package org.openhab.persistence.jdbc.internal.utils;
import java.net.URI;
import java.net.URISyntaxException;

2
bundles/org.openhab.persistence.jdbc/src/test/java/org/openhab/persistence/jdbc/internal/NamingStrategyTest.java
View File

@ -30,7 +30,7 @@ import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.openhab.persistence.jdbc.dto.ItemVO;
import org.openhab.persistence.jdbc.internal.dto.ItemVO;
import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;

2
bundles/org.openhab.persistence.jdbc/src/test/java/org/openhab/persistence/jdbc/db/JdbcBaseDAOTest.java → bundles/org.openhab.persistence.jdbc/src/test/java/org/openhab/persistence/jdbc/internal/db/JdbcBaseDAOTest.java
View File

@ -10,7 +10,7 @@
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.persistence.jdbc.db;
package org.openhab.persistence.jdbc.internal.db;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;