aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rwxr-xr-xmdbc-server/src/main/java/org/onap/music/mdbc/MDBCUtils.java18
-rwxr-xr-xmdbc-server/src/main/java/org/onap/music/mdbc/MdbcConnection.java13
-rwxr-xr-xmdbc-server/src/main/java/org/onap/music/mdbc/ProxyStatement.java1302
-rw-r--r--mdbc-server/src/main/java/org/onap/music/mdbc/examples/MdbcTestClient.java23
-rw-r--r--mdbc-server/src/main/java/org/onap/music/mdbc/mixins/LockRequest.java29
-rw-r--r--mdbc-server/src/main/java/org/onap/music/mdbc/mixins/MusicMixin.java18
-rw-r--r--mdbc-server/src/main/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpoint.java22
-rw-r--r--mdbc-server/src/test/java/org/onap/music/mdbc/mixins/MusicMixinTest.java11
-rw-r--r--mdbc-server/src/test/java/org/onap/music/mdbc/mixins/MySQLMixinTest.java (renamed from mdbc-server/src/test/java/org/onap/music/mdbc/MySQLMixinTest.java)4
-rw-r--r--mdbc-server/src/test/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpointTest.java30
10 files changed, 132 insertions, 1338 deletions
diff --git a/mdbc-server/src/main/java/org/onap/music/mdbc/MDBCUtils.java b/mdbc-server/src/main/java/org/onap/music/mdbc/MDBCUtils.java
index ae2b869..a02e6d0 100755
--- a/mdbc-server/src/main/java/org/onap/music/mdbc/MDBCUtils.java
+++ b/mdbc-server/src/main/java/org/onap/music/mdbc/MDBCUtils.java
@@ -38,6 +38,7 @@ import org.onap.music.logging.format.ErrorTypes;
import org.onap.music.mdbc.mixins.MusicMixin;
import org.onap.music.mdbc.mixins.Utils;
import org.onap.music.mdbc.query.SQLOperation;
+import org.onap.music.mdbc.query.SQLOperationType;
import org.onap.music.mdbc.tables.Operation;
import org.onap.music.mdbc.tables.StagingTable;
@@ -119,4 +120,21 @@ public class MDBCUtils {
}
return ranges;
}
+
+ /**
+ * determine the type of operation contained in the table to query map
+ *
+ * @param tableToQueryType
+ * @return write if any table has a write query. Read otherwise
+ */
+ public static SQLOperationType getOperationType(Map<String, List<SQLOperation>> tableToQueryType) {
+ for (List<org.onap.music.mdbc.query.SQLOperation> tablesOps : tableToQueryType.values()) {
+ for (org.onap.music.mdbc.query.SQLOperation op : tablesOps) {
+ if (op.getOperationType() != SQLOperationType.READ) {
+ return SQLOperationType.WRITE;
+ }
+ }
+ }
+ return SQLOperationType.READ;
+ }
} \ No newline at end of file
diff --git a/mdbc-server/src/main/java/org/onap/music/mdbc/MdbcConnection.java b/mdbc-server/src/main/java/org/onap/music/mdbc/MdbcConnection.java
index b4d7bb9..3743638 100755
--- a/mdbc-server/src/main/java/org/onap/music/mdbc/MdbcConnection.java
+++ b/mdbc-server/src/main/java/org/onap/music/mdbc/MdbcConnection.java
@@ -54,6 +54,7 @@ import org.onap.music.mdbc.ownership.DagNode;
import org.onap.music.mdbc.ownership.OwnershipAndCheckpoint;
import org.onap.music.mdbc.query.QueryProcessor;
import org.onap.music.mdbc.query.SQLOperation;
+import org.onap.music.mdbc.query.SQLOperationType;
import org.onap.music.mdbc.tables.MusicTxDigestDaemon;
import org.onap.music.mdbc.tables.MusicRangeInformationRow;
import org.onap.music.mdbc.tables.StagingTable;
@@ -500,10 +501,10 @@ public class MdbcConnection implements Connection {
public void preStatementHook(final String sql) throws MDBCServiceException, SQLException {
//TODO: verify ownership of keys here
//Parse tables from the sql query
- Map<String, List<SQLOperation>> tableToInstruction = QueryProcessor.parseSqlQuery(sql, table_set);
+ Map<String, List<SQLOperation>> tableToQueryType = QueryProcessor.parseSqlQuery(sql, table_set);
//Check ownership of keys
String defaultSchema = dbi.getSchema();
- List<Range> queryTables = MDBCUtils.getTables(defaultSchema, tableToInstruction);
+ List<Range> queryTables = MDBCUtils.getTables(defaultSchema, tableToQueryType);
if (this.partition!=null) {
List<Range> snapshot = this.partition.getSnapshot();
if(snapshot!=null){
@@ -512,8 +513,8 @@ public class MdbcConnection implements Connection {
}
// filter out ranges that fall under Eventually consistent
// category as these tables do not need ownership
- List<Range> scQueryTables = filterEveTables( queryTables);
- DatabasePartition tempPartition = own(scQueryTables);
+ List<Range> scQueryTables = filterEveTables(queryTables);
+ DatabasePartition tempPartition = own(scQueryTables, MDBCUtils.getOperationType(tableToQueryType));
if(tempPartition!=null && tempPartition != partition) {
this.partition.updateDatabasePartition(tempPartition);
statemanager.getOwnAndCheck().reloadAlreadyApplied(this.partition);
@@ -576,7 +577,7 @@ public class MdbcConnection implements Connection {
* @return
* @throws MDBCServiceException
*/
- private DatabasePartition own(List<Range> ranges) throws MDBCServiceException {
+ private DatabasePartition own(List<Range> ranges, SQLOperationType lockType) throws MDBCServiceException {
if(ranges==null||ranges.isEmpty()){
return null;
}
@@ -584,7 +585,7 @@ public class MdbcConnection implements Connection {
OwnershipAndCheckpoint ownAndCheck = statemanager.getOwnAndCheck();
UUID ownOpId = MDBCUtils.generateTimebasedUniqueKey();
try {
- final OwnershipReturn ownershipReturn = ownAndCheck.own(mi, ranges, partition, ownOpId);
+ final OwnershipReturn ownershipReturn = ownAndCheck.own(mi, ranges, partition, ownOpId, lockType);
if(ownershipReturn==null){
return null;
}
diff --git a/mdbc-server/src/main/java/org/onap/music/mdbc/ProxyStatement.java b/mdbc-server/src/main/java/org/onap/music/mdbc/ProxyStatement.java
deleted file mode 100755
index 2c3e6b9..0000000
--- a/mdbc-server/src/main/java/org/onap/music/mdbc/ProxyStatement.java
+++ /dev/null
@@ -1,1302 +0,0 @@
-/*
- * ============LICENSE_START====================================================
- * org.onap.music.mdbc
- * =============================================================================
- * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
- * =============================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END======================================================
- */
-package org.onap.music.mdbc;
-
-import java.io.InputStream;
-import java.io.Reader;
-import java.math.BigDecimal;
-import java.net.URL;
-import java.sql.Array;
-import java.sql.Blob;
-import java.sql.CallableStatement;
-import java.sql.Clob;
-import java.sql.Connection;
-import java.sql.Date;
-import java.sql.NClob;
-import java.sql.ParameterMetaData;
-import java.sql.PreparedStatement;
-import java.sql.Ref;
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.RowId;
-import java.sql.SQLException;
-import java.sql.SQLWarning;
-import java.sql.SQLXML;
-import java.sql.Statement;
-import java.sql.Time;
-import java.sql.Timestamp;
-import java.util.Calendar;
-import java.util.Map;
-
-import org.onap.music.exceptions.MDBCServiceException;
-import org.onap.music.exceptions.QueryException;
-import org.onap.music.logging.EELFLoggerDelegate;
-
-/**
- * ProxyStatement is a proxy Statement that front ends Statements from the underlying JDBC driver. It passes all operations through,
- * and invokes the MusicSqlManager when there is the possibility that database tables have been created or dropped.
- *
- * @author Robert Eby
- */
-public class ProxyStatement implements CallableStatement {
- private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ProxyStatement.class);
- private static final String DATASTAX_PREFIX = "com.datastax.driver";
-
- private final Statement stmt; // the Statement that we are proxying
- private final MdbcConnection mConn;
-
- public ProxyStatement(Statement s, MdbcConnection mConn) {
- this.stmt = s;
- this.mConn = mConn;
- }
-
- @Override
- public <T> T unwrap(Class<T> iface) throws SQLException {
- return stmt.unwrap(iface);
- }
-
- @Override
- public boolean isWrapperFor(Class<?> iface) throws SQLException {
- return stmt.isWrapperFor(iface);
- }
-
- @Override
- public ResultSet executeQuery(String sql) throws SQLException {
- logger.debug("executeQuery: "+sql);
- ResultSet r = null;
- try {
- mConn.preStatementHook(sql);
- r = stmt.executeQuery(sql);
- mConn.postStatementHook(sql);
- synchronizeTables(sql);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- logger.warn("executeQuery: exception "+nm);
- if (!nm.startsWith(DATASTAX_PREFIX))
- throw e;
- } catch (MDBCServiceException e) {
- throw new SQLException(e.getMessage(), e);
- }
-
- return r;
- }
-
- @Override
- public int executeUpdate(String sql) throws SQLException {
- logger.debug("executeUpdate: "+sql);
- int n = 0;
- try {
- mConn.preStatementHook(sql);
- n = stmt.executeUpdate(sql);
- mConn.postStatementHook(sql);
- synchronizeTables(sql);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- logger.warn("executeUpdate: exception "+nm);
- if (!nm.startsWith(DATASTAX_PREFIX))
- throw e;
- } catch (MDBCServiceException e) {
- throw new SQLException(e.getMessage(), e);
- }
- return n;
- }
-
- @Override
- public void close() throws SQLException {
- stmt.close();
- }
-
- @Override
- public int getMaxFieldSize() throws SQLException {
- return stmt.getMaxFieldSize();
- }
-
- @Override
- public void setMaxFieldSize(int max) throws SQLException {
- stmt.setMaxFieldSize(max);
- }
-
- @Override
- public int getMaxRows() throws SQLException {
- return stmt.getMaxRows();
- }
-
- @Override
- public void setMaxRows(int max) throws SQLException {
- stmt.setMaxRows(max);
- }
-
- @Override
- public void setEscapeProcessing(boolean enable) throws SQLException {
- stmt.setEscapeProcessing(enable);
- }
-
- @Override
- public int getQueryTimeout() throws SQLException {
- return stmt.getQueryTimeout();
- }
-
- @Override
- public void setQueryTimeout(int seconds) throws SQLException {
- stmt.setQueryTimeout(seconds);
- }
-
- @Override
- public void cancel() throws SQLException {
- stmt.cancel();
- }
-
- @Override
- public SQLWarning getWarnings() throws SQLException {
- return stmt.getWarnings();
- }
-
- @Override
- public void clearWarnings() throws SQLException {
- stmt.clearWarnings();
- }
-
- @Override
- public void setCursorName(String name) throws SQLException {
- stmt.setCursorName(name);
- }
-
- @Override
- public boolean execute(String sql) throws SQLException {
- logger.debug("execute: "+sql);
- boolean b = false;
- try {
- mConn.preStatementHook(sql);
- b = stmt.execute(sql);
- mConn.postStatementHook(sql);
- synchronizeTables(sql);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- // Note: this seems to be the only call Camunda uses, so it is the only one I am fixing for now.
- boolean ignore = nm.startsWith(DATASTAX_PREFIX);
-// ignore |= (nm.startsWith("org.h2.jdbc.JdbcSQLException") && e.getMessage().contains("already exists"));
- if (ignore) {
- logger.warn("execute: exception (IGNORED) "+nm);
- } else {
- logger.warn("execute: exception "+nm);
- throw e;
- }
- } catch (MDBCServiceException e) {
- throw new SQLException(e.getMessage(), e);
- }
- return b;
- }
-
- @Override
- public ResultSet getResultSet() throws SQLException {
- return stmt.getResultSet();
- }
-
- @Override
- public int getUpdateCount() throws SQLException {
- return stmt.getUpdateCount();
- }
-
- @Override
- public boolean getMoreResults() throws SQLException {
- return stmt.getMoreResults();
- }
-
- @Override
- public void setFetchDirection(int direction) throws SQLException {
- stmt.setFetchDirection(direction);
- }
-
- @Override
- public int getFetchDirection() throws SQLException {
- return stmt.getFetchDirection();
- }
-
- @Override
- public void setFetchSize(int rows) throws SQLException {
- stmt.setFetchSize(rows);
- }
-
- @Override
- public int getFetchSize() throws SQLException {
- return stmt.getFetchSize();
- }
-
- @Override
- public int getResultSetConcurrency() throws SQLException {
- return stmt.getResultSetConcurrency();
- }
-
- @Override
- public int getResultSetType() throws SQLException {
- return stmt.getResultSetType();
- }
-
- @Override
- public void addBatch(String sql) throws SQLException {
- stmt.addBatch(sql);
- }
-
- @Override
- public void clearBatch() throws SQLException {
- stmt.clearBatch();
- }
-
- @Override
- public int[] executeBatch() throws SQLException {
- logger.debug("executeBatch");
- int[] n = null;
- //\TODO check if this is still invalid in Metric
- try {
- logger.warn("executeBatch() is not supported by MDBC; your results may be incorrect as a result.");
- n = stmt.executeBatch();
- synchronizeTables(null);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- logger.warn("executeBatch: exception "+nm);
- if (!nm.startsWith(DATASTAX_PREFIX))
- throw e;
- }
-
- return n;
- }
-
- @Override
- public Connection getConnection() throws SQLException {
- return stmt.getConnection();
- }
-
- @Override
- public boolean getMoreResults(int current) throws SQLException {
- return stmt.getMoreResults(current);
- }
-
- @Override
- public ResultSet getGeneratedKeys() throws SQLException {
- return stmt.getGeneratedKeys();
- }
-
- @Override
- public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
- logger.debug("executeUpdate: "+sql);
- int n = 0;
- try {
- mConn.preStatementHook(sql);
- n = stmt.executeUpdate(sql, autoGeneratedKeys);
- mConn.postStatementHook(sql);
- synchronizeTables(sql);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- logger.warn("executeUpdate: exception "+nm);
- if (!nm.startsWith(DATASTAX_PREFIX))
- throw e;
- }catch (MDBCServiceException e) {
- throw new SQLException(e.getMessage(), e);
- }
- return n;
- }
-
- @Override
- public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
- logger.debug("executeUpdate: "+sql);
- int n = 0;
- try {
- mConn.preStatementHook(sql);
- n = stmt.executeUpdate(sql, columnIndexes);
- mConn.postStatementHook(sql);
- synchronizeTables(sql);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- logger.warn("executeUpdate: exception "+nm);
- if (!nm.startsWith(DATASTAX_PREFIX))
- throw e;
- }catch (MDBCServiceException e) {
- throw new SQLException(e.getMessage(), e);
- }
- return n;
- }
-
- @Override
- public int executeUpdate(String sql, String[] columnNames) throws SQLException {
- logger.debug("executeUpdate: "+sql);
- int n = 0;
- try {
- mConn.preStatementHook(sql);
- n = stmt.executeUpdate(sql, columnNames);
- mConn.postStatementHook(sql);
- synchronizeTables(sql);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- logger.warn("executeUpdate: exception "+nm);
- if (!nm.startsWith(DATASTAX_PREFIX))
- throw e;
- }catch (MDBCServiceException e) {
- throw new SQLException(e.getMessage(), e);
- }
- return n;
- }
-
- @Override
- public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
- logger.debug("execute: "+sql);
- boolean b = false;
- try {
- mConn.preStatementHook(sql);
- b = stmt.execute(sql, autoGeneratedKeys);
- mConn.postStatementHook(sql);
- synchronizeTables(sql);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- logger.warn("execute: exception "+nm);
- if (!nm.startsWith(DATASTAX_PREFIX))
- throw e;
- }catch (MDBCServiceException e) {
- throw new SQLException(e.getMessage(), e);
- }
- return b;
- }
-
- @Override
- public boolean execute(String sql, int[] columnIndexes) throws SQLException {
- logger.debug("execute: "+sql);
- boolean b = false;
- try {
- mConn.preStatementHook(sql);
- b = stmt.execute(sql, columnIndexes);
- mConn.postStatementHook(sql);
- synchronizeTables(sql);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- logger.warn("execute: exception "+nm);
- if (!nm.startsWith(DATASTAX_PREFIX))
- throw e;
- }catch (MDBCServiceException e) {
- throw new SQLException(e.getMessage(), e);
- }
- return b;
- }
-
- @Override
- public boolean execute(String sql, String[] columnNames) throws SQLException {
- logger.debug("execute: "+sql);
- boolean b = false;
- try {
- mConn.preStatementHook(sql);
- b = stmt.execute(sql, columnNames);
- mConn.postStatementHook(sql);
- synchronizeTables(sql);
- } catch (SQLException e) {
- String nm = e.getClass().getName();
- logger.warn("execute: exception "+nm);
- if (!nm.startsWith(DATASTAX_PREFIX))
- throw e;
- }catch (MDBCServiceException e) {
- throw new SQLException(e.getMessage(), e);
- }
- return b;
- }
-
- @Override
- public int getResultSetHoldability() throws SQLException {
- return stmt.getResultSetHoldability();
- }
-
- @Override
- public boolean isClosed() throws SQLException {
- return stmt.isClosed();
- }
-
- @Override
- public void setPoolable(boolean poolable) throws SQLException {
- stmt.setPoolable(poolable);
- }
-
- @Override
- public boolean isPoolable() throws SQLException {
- return stmt.isPoolable();
- }
-
- @Override
- public void closeOnCompletion() throws SQLException {
- stmt.closeOnCompletion();
- }
-
- @Override
- public boolean isCloseOnCompletion() throws SQLException {
- return stmt.isCloseOnCompletion();
- }
-
- @Override
- public ResultSet executeQuery() throws SQLException {
- logger.debug("executeQuery");
- return ((PreparedStatement)stmt).executeQuery();
- }
-
- @Override
- public int executeUpdate() throws SQLException {
- logger.debug("executeUpdate");
- return ((PreparedStatement)stmt).executeUpdate();
- }
-
- @Override
- public void setNull(int parameterIndex, int sqlType) throws SQLException {
- ((PreparedStatement)stmt).setNull(parameterIndex, sqlType);
- }
-
- @Override
- public void setBoolean(int parameterIndex, boolean x) throws SQLException {
- ((PreparedStatement)stmt).setBoolean(parameterIndex, x);
- }
-
- @Override
- public void setByte(int parameterIndex, byte x) throws SQLException {
- ((PreparedStatement)stmt).setByte(parameterIndex, x);
- }
-
- @Override
- public void setShort(int parameterIndex, short x) throws SQLException {
- ((PreparedStatement)stmt).setShort(parameterIndex, x);
- }
-
- @Override
- public void setInt(int parameterIndex, int x) throws SQLException {
- ((PreparedStatement)stmt).setInt(parameterIndex, x);
- }
-
- @Override
- public void setLong(int parameterIndex, long x) throws SQLException {
- ((PreparedStatement)stmt).setLong(parameterIndex, x);
- }
-
- @Override
- public void setFloat(int parameterIndex, float x) throws SQLException {
- ((PreparedStatement)stmt).setFloat(parameterIndex, x);
- }
-
- @Override
- public void setDouble(int parameterIndex, double x) throws SQLException {
- ((PreparedStatement)stmt).setDouble(parameterIndex, x);
- }
-
- @Override
- public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
- ((PreparedStatement)stmt).setBigDecimal(parameterIndex, x);
- }
-
- @Override
- public void setString(int parameterIndex, String x) throws SQLException {
- ((PreparedStatement)stmt).setString(parameterIndex, x);
- }
-
- @Override
- public void setBytes(int parameterIndex, byte[] x) throws SQLException {
- ((PreparedStatement)stmt).setBytes(parameterIndex, x);
- }
-
- @Override
- public void setDate(int parameterIndex, Date x) throws SQLException {
- ((PreparedStatement)stmt).setDate(parameterIndex, x);
- }
-
- @Override
- public void setTime(int parameterIndex, Time x) throws SQLException {
- ((PreparedStatement)stmt).setTime(parameterIndex, x);
- }
-
- @Override
- public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
- ((PreparedStatement)stmt).setTimestamp(parameterIndex, x);
- }
-
- @Override
- public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
- ((PreparedStatement)stmt).setAsciiStream(parameterIndex, x, length);
- }
-
- @SuppressWarnings("deprecation")
- @Override
- public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
- ((PreparedStatement)stmt).setUnicodeStream(parameterIndex, x, length);
- }
-
- @Override
- public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
- ((PreparedStatement)stmt).setBinaryStream(parameterIndex, x, length);
- }
-
- @Override
- public void clearParameters() throws SQLException {
- ((PreparedStatement)stmt).clearParameters();
- }
-
- @Override
- public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
- ((PreparedStatement)stmt).setObject(parameterIndex, x, targetSqlType);
- }
-
- @Override
- public void setObject(int parameterIndex, Object x) throws SQLException {
- ((PreparedStatement)stmt).setObject(parameterIndex, x);
- }
-
- @Override
- public boolean execute() throws SQLException {
- return ((PreparedStatement)stmt).execute();
- }
-
- @Override
- public void addBatch() throws SQLException {
- ((PreparedStatement)stmt).addBatch();
- }
-
- @Override
- public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
- ((PreparedStatement)stmt).setCharacterStream(parameterIndex, reader, length);
- }
-
- @Override
- public void setRef(int parameterIndex, Ref x) throws SQLException {
- ((PreparedStatement)stmt).setRef(parameterIndex, x);
- }
-
- @Override
- public void setBlob(int parameterIndex, Blob x) throws SQLException {
- ((PreparedStatement)stmt).setBlob(parameterIndex, x);
- }
-
- @Override
- public void setClob(int parameterIndex, Clob x) throws SQLException {
- ((PreparedStatement)stmt).setClob(parameterIndex, x);
- }
-
- @Override
- public void setArray(int parameterIndex, Array x) throws SQLException {
- ((PreparedStatement)stmt).setArray(parameterIndex, x);
- }
-
- @Override
- public ResultSetMetaData getMetaData() throws SQLException {
- return ((PreparedStatement)stmt).getMetaData();
- }
-
- @Override
- public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
- ((PreparedStatement)stmt).setDate(parameterIndex, x, cal);
- }
-
- @Override
- public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
- ((PreparedStatement)stmt).setTime(parameterIndex, x, cal);
- }
-
- @Override
- public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
- ((CallableStatement)stmt).setTimestamp(parameterIndex, x, cal);
- }
-
- @Override
- public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException {
- ((CallableStatement)stmt).setNull(parameterIndex, sqlType, typeName);
- }
-
- @Override
- public void setURL(int parameterIndex, URL x) throws SQLException {
- ((CallableStatement)stmt).setURL(parameterIndex, x);
- }
-
- @Override
- public ParameterMetaData getParameterMetaData() throws SQLException {
- return ((CallableStatement)stmt).getParameterMetaData();
- }
-
- @Override
- public void setRowId(int parameterIndex, RowId x) throws SQLException {
- ((CallableStatement)stmt).setRowId(parameterIndex, x);
- }
-
- @Override
- public void setNString(int parameterIndex, String value) throws SQLException {
- ((CallableStatement)stmt).setNString(parameterIndex, value);
- }
-
- @Override
- public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
- ((CallableStatement)stmt).setNCharacterStream(parameterIndex, value, length);
- }
-
- @Override
- public void setNClob(int parameterIndex, NClob value) throws SQLException {
- ((CallableStatement)stmt).setNClob(parameterIndex, value);
- }
-
- @Override
- public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
- ((CallableStatement)stmt).setClob(parameterIndex, reader, length);
- }
-
- @Override
- public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
- ((CallableStatement)stmt).setBlob(parameterIndex, inputStream, length);
- }
-
- @Override
- public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
- ((CallableStatement)stmt).setNClob(parameterIndex, reader, length);
- }
-
- @Override
- public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
- ((CallableStatement)stmt).setSQLXML(parameterIndex, xmlObject);
- }
-
- @Override
- public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
- ((CallableStatement)stmt).setObject(parameterIndex, x, targetSqlType, scaleOrLength);
- }
-
- @Override
- public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
- ((CallableStatement)stmt).setAsciiStream(parameterIndex, x, length);
- }
-
- @Override
- public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
- ((CallableStatement)stmt).setBinaryStream(parameterIndex, x, length);
- }
-
- @Override
- public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
- ((CallableStatement)stmt).setCharacterStream(parameterIndex, reader, length);
- }
-
- @Override
- public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
- ((CallableStatement)stmt).setAsciiStream(parameterIndex, x);
- }
-
- @Override
- public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
- ((CallableStatement)stmt).setBinaryStream(parameterIndex, x);
- }
-
- @Override
- public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
- ((CallableStatement)stmt).setCharacterStream(parameterIndex, reader);
- }
-
- @Override
- public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
- ((CallableStatement)stmt).setNCharacterStream(parameterIndex, value);
- }
-
- @Override
- public void setClob(int parameterIndex, Reader reader) throws SQLException {
- ((CallableStatement)stmt).setClob(parameterIndex, reader);
- }
-
- @Override
- public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
- ((CallableStatement)stmt).setBlob(parameterIndex, inputStream);
- }
-
- @Override
- public void setNClob(int parameterIndex, Reader reader) throws SQLException {
- ((CallableStatement)stmt).setNClob(parameterIndex, reader);
- }
-
- @Override
- public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException {
- ((CallableStatement)stmt).registerOutParameter(parameterIndex, sqlType);
- }
-
- @Override
- public void registerOutParameter(int parameterIndex, int sqlType, int scale) throws SQLException {
- ((CallableStatement)stmt).registerOutParameter(parameterIndex, sqlType, scale);
- }
-
- @Override
- public boolean wasNull() throws SQLException {
- return ((CallableStatement)stmt).wasNull();
- }
-
- @Override
- public String getString(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getString(parameterIndex);
- }
-
- @Override
- public boolean getBoolean(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getBoolean(parameterIndex);
- }
-
- @Override
- public byte getByte(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getByte(parameterIndex);
- }
-
- @Override
- public short getShort(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getShort(parameterIndex);
- }
-
- @Override
- public int getInt(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getInt(parameterIndex);
- }
-
- @Override
- public long getLong(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getLong(parameterIndex);
- }
-
- @Override
- public float getFloat(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getFloat(parameterIndex);
- }
-
- @Override
- public double getDouble(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getDouble(parameterIndex);
- }
-
- @SuppressWarnings("deprecation")
- @Override
- public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException {
- return ((CallableStatement)stmt).getBigDecimal(parameterIndex, scale);
- }
-
- @Override
- public byte[] getBytes(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getBytes(parameterIndex);
- }
-
- @Override
- public Date getDate(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getDate(parameterIndex);
- }
-
- @Override
- public Time getTime(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getTime(parameterIndex);
- }
-
- @Override
- public Timestamp getTimestamp(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getTimestamp(parameterIndex);
- }
-
- @Override
- public Object getObject(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getObject(parameterIndex);
- }
-
- @Override
- public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getBigDecimal(parameterIndex);
- }
-
- @Override
- public Object getObject(int parameterIndex, Map<String, Class<?>> map) throws SQLException {
- return ((CallableStatement)stmt).getObject(parameterIndex, map);
- }
-
- @Override
- public Ref getRef(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getRef(parameterIndex);
- }
-
- @Override
- public Blob getBlob(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getBlob(parameterIndex);
- }
-
- @Override
- public Clob getClob(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getClob(parameterIndex);
- }
-
- @Override
- public Array getArray(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getArray(parameterIndex);
- }
-
- @Override
- public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
- return ((CallableStatement)stmt).getDate(parameterIndex, cal);
- }
-
- @Override
- public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
- return ((CallableStatement)stmt).getTime(parameterIndex, cal);
- }
-
- @Override
- public Timestamp getTimestamp(int parameterIndex, Calendar cal) throws SQLException {
- return ((CallableStatement)stmt).getTimestamp(parameterIndex, cal);
- }
-
- @Override
- public void registerOutParameter(int parameterIndex, int sqlType, String typeName) throws SQLException {
- ((CallableStatement)stmt).registerOutParameter(parameterIndex, sqlType, typeName);
- }
-
- @Override
- public void registerOutParameter(String parameterName, int sqlType) throws SQLException {
- ((CallableStatement)stmt).registerOutParameter(parameterName, sqlType);
- }
-
- @Override
- public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException {
- ((CallableStatement)stmt).registerOutParameter(parameterName, sqlType, scale);
- }
-
- @Override
- public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLException {
- ((CallableStatement)stmt).registerOutParameter(parameterName, sqlType, typeName);
- }
-
- @Override
- public URL getURL(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getURL(parameterIndex);
- }
-
- @Override
- public void setURL(String parameterName, URL val) throws SQLException {
- ((CallableStatement)stmt).setURL(parameterName, val);
- }
-
- @Override
- public void setNull(String parameterName, int sqlType) throws SQLException {
- ((CallableStatement)stmt).setNull(parameterName, sqlType);
- }
-
- @Override
- public void setBoolean(String parameterName, boolean x) throws SQLException {
- ((CallableStatement)stmt).setBoolean(parameterName, x);
- }
-
- @Override
- public void setByte(String parameterName, byte x) throws SQLException {
- ((CallableStatement)stmt).setByte(parameterName, x);
- }
-
- @Override
- public void setShort(String parameterName, short x) throws SQLException {
- ((CallableStatement)stmt).setShort(parameterName, x);
- }
-
- @Override
- public void setInt(String parameterName, int x) throws SQLException {
- ((CallableStatement)stmt).setInt(parameterName, x);
- }
-
- @Override
- public void setLong(String parameterName, long x) throws SQLException {
- ((CallableStatement)stmt).setLong(parameterName, x);
- }
-
- @Override
- public void setFloat(String parameterName, float x) throws SQLException {
- ((CallableStatement)stmt).setFloat(parameterName, x);
- }
-
- @Override
- public void setDouble(String parameterName, double x) throws SQLException {
- ((CallableStatement)stmt).setDouble(parameterName, x);
- }
-
- @Override
- public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
- ((CallableStatement)stmt).setBigDecimal(parameterName, x);
- }
-
- @Override
- public void setString(String parameterName, String x) throws SQLException {
- ((CallableStatement)stmt).setString(parameterName, x);
- }
-
- @Override
- public void setBytes(String parameterName, byte[] x) throws SQLException {
- ((CallableStatement)stmt).setBytes(parameterName, x);
- }
-
- @Override
- public void setDate(String parameterName, Date x) throws SQLException {
- ((CallableStatement)stmt).setDate(parameterName, x);
- }
-
- @Override
- public void setTime(String parameterName, Time x) throws SQLException {
- ((CallableStatement)stmt).setTime(parameterName, x);
- }
-
- @Override
- public void setTimestamp(String parameterName, Timestamp x) throws SQLException {
- ((CallableStatement)stmt).setTimestamp(parameterName, x);
- }
-
- @Override
- public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException {
- ((CallableStatement)stmt).setAsciiStream(parameterName, x, length);
- }
-
- @Override
- public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
- ((CallableStatement)stmt).setBinaryStream(parameterName, x, length);
- }
-
- @Override
- public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException {
- ((CallableStatement)stmt).setObject(parameterName, x, targetSqlType, scale);
- }
-
- @Override
- public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException {
- ((CallableStatement)stmt).setObject(parameterName, x, targetSqlType);
- }
-
- @Override
- public void setObject(String parameterName, Object x) throws SQLException {
- ((CallableStatement)stmt).setObject(parameterName, x);
- }
-
- @Override
- public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException {
- ((CallableStatement)stmt).setCharacterStream(parameterName, reader, length);
- }
-
- @Override
- public void setDate(String parameterName, Date x, Calendar cal) throws SQLException {
- ((CallableStatement)stmt).setDate(parameterName, x, cal);
- }
-
- @Override
- public void setTime(String parameterName, Time x, Calendar cal) throws SQLException {
- ((CallableStatement)stmt).setTime(parameterName, x, cal);
- }
-
- @Override
- public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException {
- ((CallableStatement)stmt).setTimestamp(parameterName, x, cal);
- }
-
- @Override
- public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
- ((CallableStatement)stmt).setNull(parameterName, sqlType, typeName);
- }
-
- @Override
- public String getString(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getString(parameterName);
- }
-
- @Override
- public boolean getBoolean(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getBoolean(parameterName);
- }
-
- @Override
- public byte getByte(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getByte(parameterName);
- }
-
- @Override
- public short getShort(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getShort(parameterName);
- }
-
- @Override
- public int getInt(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getInt(parameterName);
- }
-
- @Override
- public long getLong(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getLong(parameterName);
- }
-
- @Override
- public float getFloat(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getFloat(parameterName);
- }
-
- @Override
- public double getDouble(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getDouble(parameterName);
- }
-
- @Override
- public byte[] getBytes(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getBytes(parameterName);
- }
-
- @Override
- public Date getDate(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getDate(parameterName);
- }
-
- @Override
- public Time getTime(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getTime(parameterName);
- }
-
- @Override
- public Timestamp getTimestamp(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getTimestamp(parameterName);
- }
-
- @Override
- public Object getObject(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getObject(parameterName);
- }
-
- @Override
- public BigDecimal getBigDecimal(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getBigDecimal(parameterName);
- }
-
- @Override
- public Object getObject(String parameterName, Map<String, Class<?>> map) throws SQLException {
- return ((CallableStatement)stmt).getObject(parameterName, map);
- }
-
- @Override
- public Ref getRef(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getRef(parameterName);
- }
-
- @Override
- public Blob getBlob(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getBlob(parameterName);
- }
-
- @Override
- public Clob getClob(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getClob(parameterName);
- }
-
- @Override
- public Array getArray(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getArray(parameterName);
- }
-
- @Override
- public Date getDate(String parameterName, Calendar cal) throws SQLException {
- return ((CallableStatement)stmt).getDate(parameterName, cal);
- }
-
- @Override
- public Time getTime(String parameterName, Calendar cal) throws SQLException {
- return ((CallableStatement)stmt).getTime(parameterName, cal);
- }
-
- @Override
- public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLException {
- return ((CallableStatement)stmt).getTimestamp(parameterName, cal);
- }
-
- @Override
- public URL getURL(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getURL(parameterName);
- }
-
- @Override
- public RowId getRowId(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getRowId(parameterIndex);
- }
-
- @Override
- public RowId getRowId(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getRowId(parameterName);
- }
-
- @Override
- public void setRowId(String parameterName, RowId x) throws SQLException {
- ((CallableStatement)stmt).setRowId(parameterName, x);
- }
-
- @Override
- public void setNString(String parameterName, String value) throws SQLException {
- ((CallableStatement)stmt).setNString(parameterName, value);
- }
-
- @Override
- public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
- ((CallableStatement)stmt).setNCharacterStream(parameterName, value, length);
- }
-
- @Override
- public void setNClob(String parameterName, NClob value) throws SQLException {
- ((CallableStatement)stmt).setNClob(parameterName, value);
- }
-
- @Override
- public void setClob(String parameterName, Reader reader, long length) throws SQLException {
- ((CallableStatement)stmt).setClob(parameterName, reader, length);
- }
-
- @Override
- public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
- ((CallableStatement)stmt).setBlob(parameterName, inputStream, length);
- }
-
- @Override
- public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
- ((CallableStatement)stmt).setNClob(parameterName, reader, length);
- }
-
- @Override
- public NClob getNClob(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getNClob(parameterIndex);
- }
-
- @Override
- public NClob getNClob(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getNClob(parameterName);
- }
-
- @Override
- public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
- ((CallableStatement)stmt).setSQLXML(parameterName, xmlObject);
- }
-
- @Override
- public SQLXML getSQLXML(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getSQLXML(parameterIndex);
- }
-
- @Override
- public SQLXML getSQLXML(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getSQLXML(parameterName);
- }
-
- @Override
- public String getNString(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getNString(parameterIndex);
- }
-
- @Override
- public String getNString(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getNString(parameterName);
- }
-
- @Override
- public Reader getNCharacterStream(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getNCharacterStream(parameterIndex);
- }
-
- @Override
- public Reader getNCharacterStream(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getNCharacterStream(parameterName);
- }
-
- @Override
- public Reader getCharacterStream(int parameterIndex) throws SQLException {
- return ((CallableStatement)stmt).getCharacterStream(parameterIndex);
- }
-
- @Override
- public Reader getCharacterStream(String parameterName) throws SQLException {
- return ((CallableStatement)stmt).getCharacterStream(parameterName);
- }
-
- @Override
- public void setBlob(String parameterName, Blob x) throws SQLException {
- ((CallableStatement)stmt).setBlob(parameterName, x);
- }
-
- @Override
- public void setClob(String parameterName, Clob x) throws SQLException {
- ((CallableStatement)stmt).setClob(parameterName, x);
- }
-
- @Override
- public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
- ((CallableStatement)stmt).setAsciiStream(parameterName, x, length);
- }
-
- @Override
- public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
- ((CallableStatement)stmt).setBinaryStream(parameterName, x, length);
- }
-
- @Override
- public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
- ((CallableStatement)stmt).setCharacterStream(parameterName, reader, length);
- }
-
- @Override
- public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
- ((CallableStatement)stmt).setAsciiStream(parameterName, x);
- }
-
- @Override
- public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
- ((CallableStatement)stmt).setBinaryStream(parameterName, x);
- }
-
- @Override
- public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
- ((CallableStatement)stmt).setCharacterStream(parameterName, reader);
- }
-
- @Override
- public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
- ((CallableStatement)stmt).setNCharacterStream(parameterName, value);
- }
-
- @Override
- public void setClob(String parameterName, Reader reader) throws SQLException {
- ((CallableStatement)stmt).setClob(parameterName, reader);
- }
-
- @Override
- public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
- ((CallableStatement)stmt).setBlob(parameterName, inputStream);
- }
-
- @Override
- public void setNClob(String parameterName, Reader reader) throws SQLException {
- ((CallableStatement)stmt).setNClob(parameterName, reader);
- }
-
- @Override
- public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException {
- return ((CallableStatement)stmt).getObject(parameterIndex, type);
- }
-
- @Override
- public <T> T getObject(String parameterName, Class<T> type) throws SQLException {
- return ((CallableStatement)stmt).getObject(parameterName, type);
- }
-
- private void synchronizeTables(String sql) {
- if (sql == null || sql.trim().toLowerCase().startsWith("create")) {
- if (mConn != null) {
- try {
- mConn.synchronizeTables();
- } catch (QueryException e) {
-
- e.printStackTrace();
- }
- }
- }
- }
-}
diff --git a/mdbc-server/src/main/java/org/onap/music/mdbc/examples/MdbcTestClient.java b/mdbc-server/src/main/java/org/onap/music/mdbc/examples/MdbcTestClient.java
index 1c42865..fea329d 100644
--- a/mdbc-server/src/main/java/org/onap/music/mdbc/examples/MdbcTestClient.java
+++ b/mdbc-server/src/main/java/org/onap/music/mdbc/examples/MdbcTestClient.java
@@ -20,6 +20,7 @@
package org.onap.music.mdbc.examples;
import java.sql.*;
+import java.util.Scanner;
import org.apache.calcite.avatica.remote.Driver;
public class MdbcTestClient {
@@ -107,9 +108,11 @@ public class MdbcTestClient {
final String insertSQL = "INSERT INTO Persons VALUES (1, 'Martinez', 'Juan', 'KACB', 'ATLANTA');";
final String insertSQL1 = "DELETE FROM Persons WHERE PersonID=2;";
- final String insertSQL2 = "INSERT INTO Persons2 VALUES (2, 'Smith', 'JOHN', 'GNOC', 'BEDMINSTER');";
+ final String insertSQL2 = "INSERT INTO Persons VALUES (2, 'Smith', 'JOHN', 'GNOC', 'BEDMINSTER');";
final String insertSQL3 = "UPDATE Persons SET FirstName='JOSH' WHERE LastName='Smith';";
final String insertSQL4 = "UPDATE Persons SET FirstName='JOHN' WHERE LastName='Smith';";
+
+ final String selectSQL1 = "SELECT * FROM Persons;";
Statement insertStmt;
try {
@@ -120,17 +123,31 @@ public class MdbcTestClient {
}
try {
- execute = insertStmt.execute(insertSQL);
+ //execute = insertStmt.execute(insertSQL);
//execute = insertStmt.execute(insertSQL1);
- execute = insertStmt.execute(insertSQL2);
+ //execute = insertStmt.execute(insertSQL2);
//execute = insertStmt.execute(insertSQL3);
//execute = insertStmt.execute(insertSQL4);
+
+ ///*
+ ResultSet rs = insertStmt.executeQuery(selectSQL1);
+ while (rs.next()) {
+ System.out.printf("%d, %s, %s\n", rs.getInt("PersonID"), rs.getString("FirstName"), rs.getString("LastName"));
+ }
+ //pause for user input
+ Scanner scanner = new Scanner(System.in);
+ System.out.println("Please hit <Enter> to complete the transaction and continue");
+ String line = scanner.nextLine();
+ scanner.close();
+ //*/
} catch (SQLException e) {
e.printStackTrace();
return;
}
+
+
try {
connection.commit();
} catch (SQLException e) {
diff --git a/mdbc-server/src/main/java/org/onap/music/mdbc/mixins/LockRequest.java b/mdbc-server/src/main/java/org/onap/music/mdbc/mixins/LockRequest.java
index e8b400b..66c7c3e 100644
--- a/mdbc-server/src/main/java/org/onap/music/mdbc/mixins/LockRequest.java
+++ b/mdbc-server/src/main/java/org/onap/music/mdbc/mixins/LockRequest.java
@@ -23,11 +23,12 @@ package org.onap.music.mdbc.mixins;
import java.util.List;
import java.util.UUID;
import org.onap.music.mdbc.Range;
+import org.onap.music.mdbc.query.SQLOperationType;
public class LockRequest {
- private final String table;
private final UUID id;
private final List<Range> toLockRanges;
+ private SQLOperationType lockType;
private int numOfAttempts;
/**
@@ -36,10 +37,24 @@ public class LockRequest {
* @param id
* @param toLockRanges
*/
- public LockRequest(String table, UUID id, List<Range> toLockRanges) {
- this.table = table;
+ public LockRequest(UUID id, List<Range> toLockRanges) {
this.id = id;
this.toLockRanges = toLockRanges;
+ lockType = SQLOperationType.WRITE;
+ numOfAttempts = 1;
+ }
+
+ /**
+ *
+ * @param table
+ * @param id
+ * @param toLockRanges
+ * @param lockType
+ */
+ public LockRequest(UUID id, List<Range> toLockRanges, SQLOperationType lockType) {
+ this.id = id;
+ this.toLockRanges = toLockRanges;
+ this.lockType = lockType;
numOfAttempts = 1;
}
@@ -50,10 +65,6 @@ public class LockRequest {
public List<Range> getToLockRanges() {
return toLockRanges;
}
-
- public String getTable() {
- return table;
- }
/**
* Number of times you've requested this lock
@@ -66,4 +77,8 @@ public class LockRequest {
public void incrementAttempts() {
numOfAttempts++;
}
+
+ public SQLOperationType getLockType() {
+ return lockType;
+ }
} \ No newline at end of file
diff --git a/mdbc-server/src/main/java/org/onap/music/mdbc/mixins/MusicMixin.java b/mdbc-server/src/main/java/org/onap/music/mdbc/mixins/MusicMixin.java
index 5a322f3..d934473 100644
--- a/mdbc-server/src/main/java/org/onap/music/mdbc/mixins/MusicMixin.java
+++ b/mdbc-server/src/main/java/org/onap/music/mdbc/mixins/MusicMixin.java
@@ -61,6 +61,7 @@ import org.onap.music.mdbc.StateManager;
import org.onap.music.mdbc.TableInfo;
import org.onap.music.mdbc.ownership.Dag;
import org.onap.music.mdbc.ownership.DagNode;
+import org.onap.music.mdbc.query.SQLOperationType;
import org.onap.music.mdbc.tables.MriReference;
import org.onap.music.mdbc.tables.MusicRangeInformationRow;
import org.onap.music.mdbc.tables.MusicTxDigestId;
@@ -107,7 +108,7 @@ public class MusicMixin implements MusicInterface {
/** The default property value to use for the Cassandra IP address. */
public static final String DEFAULT_MUSIC_ADDRESS = "localhost";
/** The default property value to use for the Cassandra replication factor. */
- public static final int DEFAULT_MUSIC_RFACTOR = 3;
+ public static final int DEFAULT_MUSIC_RFACTOR = 1;
/** The default property value to use for the MDBC timeout */
public static final long DEFAULT_TIMEOUT = 5*60*60*1000;//default of 5 hours
/** The default primary string column, if none is provided. */
@@ -1198,7 +1199,7 @@ public class MusicMixin implements MusicInterface {
Map<UUID, LockResult> alreadyHeldLocks)
throws MDBCServiceException{
List<Range> newRanges = new ArrayList<>();
- String newFullyQualifiedKey = music_ns + "." + request.getTable() + "." + pending.getKey().toString();
+ String newFullyQualifiedKey = music_ns + "." + musicRangeInformationTableName + "." + pending.getKey().toString();
String newLockId;
boolean success;
if (currentLockRef.containsKey(pending.getKey())) {
@@ -2074,8 +2075,9 @@ public class MusicMixin implements MusicInterface {
@Override
public LockResult requestLock(LockRequest request) throws MDBCServiceException{
- String fullyQualifiedKey= music_ns+"."+ request.getTable()+"."+request.getId();
- String lockId = MusicCore.createLockReference(fullyQualifiedKey);
+ String fullyQualifiedKey= music_ns+"."+ musicRangeInformationTableName + "." + request.getId();
+ boolean isWrite = (request.getLockType()==SQLOperationType.WRITE);
+ String lockId = MusicCore.createLockReference(fullyQualifiedKey, isWrite);
ReturnType lockReturn = acquireLock(fullyQualifiedKey,lockId);
if(lockReturn.getResult() == ResultType.FAILURE) {
//\TODO Improve the exponential backoff
@@ -2090,6 +2092,14 @@ public class MusicMixin implements MusicInterface {
return new LockResult(true, request.getId(),lockId,true,null);
}
+ /**
+ * fixes the DAG in case the previous owner failed while trying to own the row
+ * @param latestDag
+ * @param rows
+ * @param ranges
+ * @param locks
+ * @throws MDBCServiceException
+ */
private void recoverFromFailureAndUpdateDag(Dag latestDag,List<MusicRangeInformationRow> rows,List<Range> ranges,
Map<UUID,LockResult> locks) throws MDBCServiceException{
Pair<List<Range>,Set<DagNode>> rangesAndDependents = latestDag.getIncompleteRangesAndDependents();
diff --git a/mdbc-server/src/main/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpoint.java b/mdbc-server/src/main/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpoint.java
index 110cc80..c7a2b5b 100644
--- a/mdbc-server/src/main/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpoint.java
+++ b/mdbc-server/src/main/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpoint.java
@@ -37,6 +37,7 @@ import org.onap.music.mdbc.mixins.LockResult;
import org.onap.music.mdbc.mixins.MusicInterface;
import org.onap.music.mdbc.mixins.MusicInterface.OwnershipReturn;
import org.onap.music.mdbc.mixins.MusicMixin;
+import org.onap.music.mdbc.query.SQLOperationType;
import org.onap.music.mdbc.tables.MriReference;
import org.onap.music.mdbc.tables.MusicRangeInformationRow;
import org.onap.music.mdbc.tables.MusicTxDigestId;
@@ -278,7 +279,7 @@ public class OwnershipAndCheckpoint{
* @throws MDBCServiceException
*/
public OwnershipReturn own(MusicInterface mi, List<Range> ranges,
- DatabasePartition currPartition, UUID opId) throws MDBCServiceException {
+ DatabasePartition currPartition, UUID opId, SQLOperationType lockType) throws MDBCServiceException {
if (ranges == null || ranges.isEmpty()) {
return null;
@@ -299,7 +300,7 @@ public class OwnershipAndCheckpoint{
while ( (toOwn.isDifferent(currentlyOwn) || !currentlyOwn.isOwned() ) &&
!timeout(opId)
) {
- takeOwnershipOfDag(mi, currPartition, opId, newLocks, toOwn);
+ takeOwnershipOfDag(mi, currPartition, opId, newLocks, toOwn, lockType);
currentlyOwn=toOwn;
//TODO instead of comparing dags, compare rows
rangesToOwnRows = extractRowsForRange(mi, rangesToOwn, false);
@@ -325,24 +326,25 @@ public class OwnershipAndCheckpoint{
* @param opId
* @param newLocks
* @param toOwn
+ * @param lockType
* @throws MDBCServiceException
*/
private void takeOwnershipOfDag(MusicInterface mi, DatabasePartition partition, UUID opId,
- Map<UUID, LockResult> newLocks, Dag toOwn) throws MDBCServiceException {
+ Map<UUID, LockResult> newLocks, Dag toOwn, SQLOperationType lockType) throws MDBCServiceException {
while(toOwn.hasNextToOwn()){
DagNode node = toOwn.nextToOwn();
MusicRangeInformationRow row = node.getRow();
- UUID uuid = row.getPartitionIndex();
- if (partition.isLocked() && partition.getMRIIndex().equals(uuid) ) {
+ UUID uuidToOwn = row.getPartitionIndex();
+ if (partition.isLocked() && partition.getMRIIndex().equals(uuidToOwn) ) {
toOwn.setOwn(node);
- newLocks.put(uuid, new LockResult(true, uuid, partition.getLockId(),
+ newLocks.put(uuidToOwn, new LockResult(true, uuidToOwn, partition.getLockId(),
false, partition.getSnapshot()));
- } else if ( newLocks.containsKey(uuid) || !row.getIsLatest() ) {
+ } else if ( newLocks.containsKey(uuidToOwn) || !row.getIsLatest() ) {
toOwn.setOwn(node);
} else {
- LockRequest request = new LockRequest(MusicMixin.musicRangeInformationTableName,uuid,
- new ArrayList(node.getRangeSet()));
+ LockRequest request = new LockRequest(uuidToOwn,
+ new ArrayList<>(node.getRangeSet()), lockType);
LockResult result = null;
boolean owned = false;
while(!owned && !timeout(opId)){
@@ -366,7 +368,7 @@ public class OwnershipAndCheckpoint{
}
if(owned){
toOwn.setOwn(node);
- newLocks.put(uuid,result);
+ newLocks.put(uuidToOwn,result);
}
else{
break;
diff --git a/mdbc-server/src/test/java/org/onap/music/mdbc/mixins/MusicMixinTest.java b/mdbc-server/src/test/java/org/onap/music/mdbc/mixins/MusicMixinTest.java
index c8d284e..e1dcc81 100644
--- a/mdbc-server/src/test/java/org/onap/music/mdbc/mixins/MusicMixinTest.java
+++ b/mdbc-server/src/test/java/org/onap/music/mdbc/mixins/MusicMixinTest.java
@@ -62,6 +62,8 @@ import org.onap.music.mdbc.Range;
import org.onap.music.mdbc.StateManager;
import org.onap.music.mdbc.proto.ProtoDigest.Digest.CompleteDigest;
+import org.onap.music.mdbc.query.SQLOperation;
+import org.onap.music.mdbc.query.SQLOperationType;
import org.onap.music.mdbc.tables.MusicRangeInformationRow;
import org.onap.music.mdbc.tables.MusicTxDigestId;
import org.onap.music.mdbc.tables.StagingTable;
@@ -130,7 +132,8 @@ public class MusicMixinTest {
DatabasePartition currentPartition = new DatabasePartition(MDBCUtils.generateTimebasedUniqueKey());
try {
- mixin.getStateManager().getOwnAndCheck().own(mixin,ranges,currentPartition, MDBCUtils.generateTimebasedUniqueKey());
+ mixin.getStateManager().getOwnAndCheck().own(mixin,ranges,currentPartition,
+ MDBCUtils.generateTimebasedUniqueKey(), SQLOperationType.WRITE);
} catch (MDBCServiceException e) {
fail("failure when running own function");
}
@@ -186,7 +189,8 @@ public class MusicMixinTest {
DatabasePartition currentPartition = new DatabasePartition(MDBCUtils.generateTimebasedUniqueKey());
MusicInterface.OwnershipReturn own = null;
try {
- own = mixin.getStateManager().getOwnAndCheck().own(mixin,range123, currentPartition, MDBCUtils.generateTimebasedUniqueKey());
+ own = mixin.getStateManager().getOwnAndCheck().own(mixin,range123, currentPartition,
+ MDBCUtils.generateTimebasedUniqueKey(), SQLOperationType.WRITE);
} catch (MDBCServiceException e) {
fail("failure when running own function");
}
@@ -231,7 +235,8 @@ public class MusicMixinTest {
MusicRangeInformationRow node3Row = mixin.getMusicRangeInformation(db3.getMRIIndex());
assertFalse(node3Row.getIsLatest());
}
-
+
+
@Test
public void relinquish() {
}
diff --git a/mdbc-server/src/test/java/org/onap/music/mdbc/MySQLMixinTest.java b/mdbc-server/src/test/java/org/onap/music/mdbc/mixins/MySQLMixinTest.java
index 862e600..1f2c1dd 100644
--- a/mdbc-server/src/test/java/org/onap/music/mdbc/MySQLMixinTest.java
+++ b/mdbc-server/src/test/java/org/onap/music/mdbc/mixins/MySQLMixinTest.java
@@ -18,7 +18,7 @@
* ============LICENSE_END======================================================
*/
-package org.onap.music.mdbc;
+package org.onap.music.mdbc.mixins;
import java.util.Properties;
import org.junit.*;
@@ -26,7 +26,7 @@ import org.junit.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
-
+import org.onap.music.mdbc.MdbcTestUtils;
import org.onap.music.mdbc.MdbcTestUtils.DBType;
import org.onap.music.mdbc.mixins.MySQLMixin;
diff --git a/mdbc-server/src/test/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpointTest.java b/mdbc-server/src/test/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpointTest.java
index f2fbd1f..2435762 100644
--- a/mdbc-server/src/test/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpointTest.java
+++ b/mdbc-server/src/test/java/org/onap/music/mdbc/ownership/OwnershipAndCheckpointTest.java
@@ -51,7 +51,9 @@ import org.onap.music.mdbc.StateManager;
import org.onap.music.mdbc.MdbcTestUtils;
import org.onap.music.mdbc.TestUtils;
import org.onap.music.mdbc.mixins.LockResult;
+import org.onap.music.mdbc.mixins.MusicInterface;
import org.onap.music.mdbc.mixins.MusicInterface.OwnershipReturn;
+import org.onap.music.mdbc.query.SQLOperationType;
import org.onap.music.mdbc.mixins.MusicMixin;
import org.onap.music.mdbc.mixins.MySQLMixin;
import org.onap.music.mdbc.tables.MusicRangeInformationRow;
@@ -175,7 +177,7 @@ public class OwnershipAndCheckpointTest {
OwnershipReturn own=null;
try {
- own = ownAndCheck.own(musicMixin, ranges, currentPartition, ownOpId);
+ own = ownAndCheck.own(musicMixin, ranges, currentPartition, ownOpId, SQLOperationType.WRITE);
} catch (MDBCServiceException e) {
fail("failure when running own function");
}
@@ -251,6 +253,32 @@ public class OwnershipAndCheckpointTest {
checkData();
}
+
+
+ @Test
+ public void readOwn() throws Exception {
+ Range range = new Range("TABLE1");
+ MusicInterface mi = MdbcTestUtils.getMusicMixin();
+ List<Range> ranges = new ArrayList<>();
+ ranges.add(range);
+ final DatabasePartition partition = TestUtils.createBasicRow(range, mi, MdbcTestUtils.getServerName());
+ TestUtils.unlockRow(MdbcTestUtils.getKeyspace(), MdbcTestUtils.getMriTableName(), partition);
+
+ DatabasePartition currentPartition = new DatabasePartition(MDBCUtils.generateTimebasedUniqueKey());
+ MusicInterface.OwnershipReturn own1, own2;
+ try {
+ own1 = ownAndCheck.own(mi, ranges, currentPartition,
+ MDBCUtils.generateTimebasedUniqueKey(), SQLOperationType.READ);
+ // acquire the table again, should be allowed since they're both reads
+ own2 = ownAndCheck.own(mi, ranges, currentPartition,
+ MDBCUtils.generateTimebasedUniqueKey(), SQLOperationType.READ);
+ } catch (MDBCServiceException e) {
+ fail("failure when running own function");
+ return;
+ }
+
+ assertEquals(own1.getRangeId(), own2.getRangeId());
+ }
private void cleanAlreadyApplied(OwnershipAndCheckpoint ownAndCheck) {
ownAndCheck.getAlreadyApplied().clear();