* ===================================================================
* Modifications Copyright (c) 2019 Samsung
* ===================================================================
+ * Modifications Copyright (C) 2019 IBM
+ * ===================================================================
* 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
import java.util.List;
import java.util.Map;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response.Status;
+
+import org.onap.music.datastore.Condition;
+import org.onap.music.datastore.MusicDataStoreHandle;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.eelf.logging.EELFLoggerDelegate;
+import org.onap.music.eelf.logging.format.AppMessages;
+import org.onap.music.eelf.logging.format.ErrorSeverity;
+import org.onap.music.eelf.logging.format.ErrorTypes;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.main.MusicUtil;
+
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.TableMetadata;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.swagger.annotations.ApiModel;
@JsonIgnoreProperties(ignoreUnknown = true)
public class JsonDelete {
+ private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(JsonDelete.class);
+
private List<String> columns = null;
private Map<String, String> consistencyInfo;
private Map<String, Object> conditions;
private String ttl;
private String timestamp;
+ private String keyspaceName;
+ private String tableName;
+ private StringBuilder rowIdString;
+ private String primarKeyValue;
@ApiModelProperty(value = "Conditions")
public void setTimestamp(String timestamp) {
this.timestamp = timestamp;
}
+
+ public String getKeyspaceName() {
+ return keyspaceName;
+ }
+
+ public void setKeyspaceName(String keyspaceName) {
+ this.keyspaceName = keyspaceName;
+ }
+
+ public String getTableName() {
+ return tableName;
+ }
+
+ public void setTableName(String tableName) {
+ this.tableName = tableName;
+ }
+
+ public StringBuilder getRowIdString() {
+ return rowIdString;
+ }
+
+ public void setRowIdString(StringBuilder rowIdString) {
+ this.rowIdString = rowIdString;
+ }
+
+ public String getPrimarKeyValue() {
+ return primarKeyValue;
+ }
+
+ public void setPrimarKeyValue(String primarKeyValue) {
+ this.primarKeyValue = primarKeyValue;
+ }
+
+
+ public PreparedQueryObject genDeletePreparedQueryObj(MultivaluedMap<String, String> rowParams) throws MusicQueryException {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Coming inside genUpdatePreparedQueryObj method " + this.getKeyspaceName());
+ logger.debug("Coming inside genUpdatePreparedQueryObj method " + this.getTableName());
+ }
+
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+
+ if((this.getKeyspaceName() == null || this.getKeyspaceName().isEmpty())
+ || (this.getTableName() == null || this.getTableName().isEmpty())){
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
+ .setError("one or more path parameters are not set, please check and try again")
+ .toMap()).build();*/
+
+ throw new MusicQueryException("one or more path parameters are not set, please check and try again",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+
+ EELFLoggerDelegate.mdcPut("keyspace", "( "+this.getKeyspaceName()+" ) ");
+
+ if(this == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,"Required HTTP Request body is missing.", AppMessages.MISSINGDATA ,ErrorSeverity.WARN, ErrorTypes.DATAERROR);
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("Required HTTP Request body is missing.").toMap()).build();*/
+
+ throw new MusicQueryException("Required HTTP Request body is missing.",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+ StringBuilder columnString = new StringBuilder();
+
+ int counter = 0;
+ List<String> columnList = this.getColumns();
+ if (columnList != null) {
+ for (String column : columnList) {
+ columnString.append(column);
+ if (counter != columnList.size() - 1)
+ columnString.append(",");
+ counter = counter + 1;
+ }
+ }
+
+ // get the row specifier
+ RowIdentifier rowId = null;
+ try {
+ rowId = getRowIdentifier(this.getKeyspaceName(), this.getTableName(), rowParams, queryObject);
+ this.setRowIdString(rowId.rowIdString);
+ this.setPrimarKeyValue(rowId.primarKeyValue);
+ if(rowId == null || rowId.primarKeyValue.isEmpty()) {
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
+ .setError("Mandatory WHERE clause is missing. Please check the input request.").toMap()).build();*/
+
+ throw new MusicQueryException("Mandatory WHERE clause is missing. Please check the input request.",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+ } catch (MusicServiceException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes
+ .GENERALSERVICEERROR, ex);
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();*/
+ throw new MusicQueryException(AppMessages.UNKNOWNERROR.toString(), Status.BAD_REQUEST.getStatusCode());
+ }
+ String rowSpec = rowId.rowIdString.toString();
+
+ if ((columnList != null) && (!rowSpec.isEmpty())) {
+ queryObject.appendQueryString("DELETE " + columnString + " FROM " + this.getKeyspaceName() + "."
+ + this.getTableName() + " WHERE " + rowSpec + ";");
+ }
+
+ if ((columnList == null) && (!rowSpec.isEmpty())) {
+ queryObject.appendQueryString("DELETE FROM " + this.getKeyspaceName() + "." + this.getTableName() + " WHERE "
+ + rowSpec + ";");
+ }
+
+ if ((columnList != null) && (rowSpec.isEmpty())) {
+ queryObject.appendQueryString(
+ "DELETE " + columnString + " FROM " + this.getKeyspaceName() + "." + rowSpec + ";");
+ }
+ // get the conditional, if any
+ Condition conditionInfo;
+ if (this.getConditions() == null) {
+ conditionInfo = null;
+ } else {
+ // to avoid parsing repeatedly, just send the select query to
+ // obtain row
+ PreparedQueryObject selectQuery = new PreparedQueryObject();
+ selectQuery.appendQueryString("SELECT * FROM " + this.getKeyspaceName() + "." + this.getTableName() + " WHERE "
+ + rowId.rowIdString + ";");
+ selectQuery.addValue(rowId.primarKeyValue);
+ conditionInfo = new Condition(this.getConditions(), selectQuery);
+ }
+
+ String consistency = this.getConsistencyInfo().get("type");
+
+
+ if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL) && this.getConsistencyInfo().get("consistency")!=null) {
+ if(MusicUtil.isValidConsistency(this.getConsistencyInfo().get("consistency"))) {
+ queryObject.setConsistency(this.getConsistencyInfo().get("consistency"));
+ } else {
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.SYNTAXERROR)
+ .setError("Invalid Consistency type").toMap()).build();*/
+ throw new MusicQueryException("Invalid Consistency type", Status.BAD_REQUEST.getStatusCode());
+ }
+ }
+
+ queryObject.setOperation("delete");
+
+ return queryObject;
+ }
+
+
+ /**
+ *
+ * @param keyspace
+ * @param tablename
+ * @param rowParams
+ * @param queryObject
+ * @return
+ * @throws MusicServiceException
+ */
+ private RowIdentifier getRowIdentifier(String keyspace, String tablename,
+ MultivaluedMap<String, String> rowParams, PreparedQueryObject queryObject)
+ throws MusicServiceException {
+ StringBuilder rowSpec = new StringBuilder();
+ int counter = 0;
+ TableMetadata tableInfo = MusicDataStoreHandle.returnColumnMetadata(keyspace, tablename);
+ if (tableInfo == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,
+ "Table information not found. Please check input for table name= "
+ + keyspace + "." + tablename);
+ throw new MusicServiceException(
+ "Table information not found. Please check input for table name= "
+ + keyspace + "." + tablename);
+ }
+ StringBuilder primaryKey = new StringBuilder();
+ for (MultivaluedMap.Entry<String, List<String>> entry : rowParams.entrySet()) {
+ String keyName = entry.getKey();
+ List<String> valueList = entry.getValue();
+ String indValue = valueList.get(0);
+ DataType colType = null;
+ Object formattedValue = null;
+ try {
+ colType = tableInfo.getColumn(entry.getKey()).getType();
+ formattedValue = MusicUtil.convertToActualDataType(colType, indValue);
+ } catch (Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e);
+ }
+ if(tableInfo.getPrimaryKey().get(0).getName().equals(entry.getKey())) {
+ primaryKey.append(indValue);
+ }
+ rowSpec.append(keyName + "= ?");
+ queryObject.addValue(formattedValue);
+ if (counter != rowParams.size() - 1) {
+ rowSpec.append(" AND ");
+ }
+ counter = counter + 1;
+ }
+ return new RowIdentifier(primaryKey.toString(), rowSpec, queryObject);
+ }
+
+ private class RowIdentifier {
+ public String primarKeyValue;
+ public StringBuilder rowIdString;
+ @SuppressWarnings("unused")
+ public PreparedQueryObject queryObject; // the string with all the row
+ // identifiers separated by AND
+
+ public RowIdentifier(String primaryKeyValue, StringBuilder rowIdString,
+ PreparedQueryObject queryObject) {
+ this.primarKeyValue = primaryKeyValue;
+ this.rowIdString = rowIdString;
+ this.queryObject = queryObject;
+ }
+ }
}
--- /dev/null
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ * Copyright (c) 2017 AT&T Intellectual Property
+ * ===================================================================
+ * Modifications Copyright (c) 2019 IBM
+ * ===================================================================
+ * 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.datastore.jsonobjects;
+
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.eelf.logging.EELFLoggerDelegate;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+@ApiModel(value = "JsonIndex", description = "Index Object")
+public class JsonIndex {
+
+ private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(JsonIndex.class);
+
+ private String indexName;
+ private String keyspaceName;
+ private String tableName;
+ private String fieldName;
+
+ public JsonIndex(String indexName,String keyspaceName,String tableName,String fieldName) {
+ this.indexName = indexName;
+ this.keyspaceName= keyspaceName;
+ this.tableName = tableName;
+ this.fieldName = fieldName;
+ }
+
+ @ApiModelProperty(value = "Index Name")
+ public String getIndexName() {
+ return indexName;
+ }
+
+ public JsonIndex setIndexName(String indexName) {
+ this.indexName = indexName;
+ return this;
+ }
+
+ @ApiModelProperty(value = "Keyspace name")
+ public String getKeyspaceName() {
+ return keyspaceName;
+ }
+
+ public JsonIndex setKeyspaceName(String keyspaceName) {
+ this.keyspaceName = keyspaceName;
+ return this;
+ }
+
+ public JsonIndex setTableName(String tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ @ApiModelProperty(value = "Table name")
+ public String getTableName() {
+ return tableName;
+ }
+
+ public JsonIndex setFieldName(String fieldName) {
+ this.fieldName = fieldName;
+ return this;
+ }
+
+ @ApiModelProperty(value = "Field name")
+ public String getFieldName() {
+ return fieldName;
+ }
+
+ public PreparedQueryObject genCreateIndexQuery() {
+
+ if (logger.isDebugEnabled()) {
+ logger.debug("Came inside genCreateIndexQuery method");
+ }
+
+ logger.info("genCreateIndexQuery indexName ::" + indexName);
+ logger.info("genCreateIndexQuery keyspaceName ::" + keyspaceName);
+ logger.info("genCreateIndexQuery tableName ::" + tableName);
+ logger.info("genCreateIndexQuery fieldName ::" + fieldName);
+
+ long start = System.currentTimeMillis();
+
+ PreparedQueryObject query = new PreparedQueryObject();
+ query.appendQueryString("Create index if not exists " + this.getIndexName() + " on " + this.getKeyspaceName() + "."
+ + this.getTableName() + " (" + this.getFieldName() + ");");
+
+ long end = System.currentTimeMillis();
+
+ logger.info(EELFLoggerDelegate.applicationLogger,
+ "Time taken for setting up query in create index:" + (end - start));
+
+ logger.info(EELFLoggerDelegate.applicationLogger,
+ " create index query :" + query.getQuery());
+
+ return query;
+ }
+
+}
* org.onap.music
* ===================================================================
* Copyright (c) 2017 AT&T Intellectual Property
- * Modifications Copyright (C) 2018 IBM.
+ * Modifications Copyright (C) 2019 IBM
* ===================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
+import java.nio.ByteBuffer;
+import java.util.List;
import java.util.Map;
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response.Status;
+import org.onap.music.datastore.MusicDataStoreHandle;
+import org.onap.music.datastore.PreparedQueryObject;
import org.onap.music.eelf.logging.EELFLoggerDelegate;
import org.onap.music.eelf.logging.format.AppMessages;
import org.onap.music.eelf.logging.format.ErrorSeverity;
import org.onap.music.eelf.logging.format.ErrorTypes;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.main.MusicUtil;
+import org.onap.music.main.ReturnType;
+
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.TableMetadata;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
@ApiModel(value = "InsertTable", description = "Json model for table vlaues insert")
@JsonIgnoreProperties(ignoreUnknown = true)
private transient Map<String, Object> rowSpecification;
private Map<String, String> consistencyInfo;
private Map<String, byte[]> objectMap;
+ private String primaryKeyVal;
private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(JsonInsert.class);
@ApiModelProperty(value = "objectMap",hidden = true)
public void setRowSpecification(Map<String, Object> rowSpecification) {
this.rowSpecification = rowSpecification;
}
+
+ public String getPrimaryKeyVal() {
+ return primaryKeyVal;
+ }
+
+ public void setPrimaryKeyVal(String primaryKeyVal) {
+ this.primaryKeyVal = primaryKeyVal;
+ }
public byte[] serialize() {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
}
return bos.toByteArray();
}
+
+ /**
+ * Generate TableInsertQuery
+ * @return
+ * @throws MusicQueryException
+ */
+ public PreparedQueryObject genInsertPreparedQueryObj() throws MusicQueryException {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Coming inside genTableInsertQuery method " + this.getKeyspaceName());
+ logger.debug("Coming inside genTableInsertQuery method " + this.getTableName());
+ }
+
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+ TableMetadata tableInfo = null;
+ try {
+ tableInfo = MusicDataStoreHandle.returnColumnMetadata(this.getKeyspaceName(), this.getTableName());
+ if(tableInfo == null) {
+ //return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("Table name doesn't exists. Please check the table name.").toMap()).build();
+ throw new MusicQueryException("Table name doesn't exists. Please check the table name.",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+ } catch (MusicServiceException e) {
+ logger.error(EELFLoggerDelegate.errorLogger, e, AppMessages.UNKNOWNERROR ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
+ //return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();
+ throw new MusicQueryException(e.getMessage(),Status.BAD_REQUEST.getStatusCode());
+
+ }
+ String primaryKeyName = tableInfo.getPrimaryKey().get(0).getName();
+ StringBuilder fieldsString = new StringBuilder("(vector_ts,");
+ String vectorTs =
+ String.valueOf(Thread.currentThread().getId() + System.currentTimeMillis());
+ StringBuilder valueString = new StringBuilder("(" + "?" + ",");
+ queryObject.addValue(vectorTs);
+
+ Map<String, Object> valuesMap = this.getValues();
+ if (valuesMap==null) {
+ //return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
+ //.setError("Nothing to insert. No values provided in request.").toMap()).build();
+ throw new MusicQueryException("Nothing to insert. No values provided in request.",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+ int counter = 0;
+ String primaryKey = "";
+ for (Map.Entry<String, Object> entry : valuesMap.entrySet()) {
+ fieldsString.append("" + entry.getKey());
+ Object valueObj = entry.getValue();
+ if (primaryKeyName.equals(entry.getKey())) {
+ primaryKey = entry.getValue() + "";
+ primaryKey = primaryKey.replace("'", "''");
+ }
+ DataType colType = null;
+ try {
+ colType = tableInfo.getColumn(entry.getKey()).getType();
+ } catch(NullPointerException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage() +" Invalid column name : "+entry.getKey
+ (), AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR, ex);
+ //return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("Invalid column name : "+entry.getKey()).toMap()).build();
+ throw new MusicQueryException("Invalid column name : " + entry.getKey(),
+ Status.BAD_REQUEST.getStatusCode());
+ }
+
+ Object formattedValue = null;
+ try {
+ formattedValue = MusicUtil.convertToActualDataType(colType, valueObj);
+ } catch (Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e);
+ }
+ valueString.append("?");
+
+ queryObject.addValue(formattedValue);
+
+ if (counter == valuesMap.size() - 1) {
+ fieldsString.append(")");
+ valueString.append(")");
+ } else {
+ fieldsString.append(",");
+ valueString.append(",");
+ }
+ counter = counter + 1;
+ }
+
+ //blobs..
+ Map<String, byte[]> objectMap = this.getObjectMap();
+ if(objectMap != null) {
+ for (Map.Entry<String, byte[]> entry : objectMap.entrySet()) {
+ if(counter > 0) {
+ fieldsString.replace(fieldsString.length()-1, fieldsString.length(), ",");
+ valueString.replace(valueString.length()-1, valueString.length(), ",");
+ }
+ fieldsString.append("" + entry.getKey());
+ byte[] valueObj = entry.getValue();
+ if (primaryKeyName.equals(entry.getKey())) {
+ primaryKey = entry.getValue() + "";
+ primaryKey = primaryKey.replace("'", "''");
+ }
+ DataType colType = tableInfo.getColumn(entry.getKey()).getType();
+ ByteBuffer formattedValue = null;
+ if(colType.toString().toLowerCase().contains("blob")) {
+ formattedValue = MusicUtil.convertToActualDataType(colType, valueObj);
+ }
+ valueString.append("?");
+ queryObject.addValue(formattedValue);
+ counter = counter + 1;
+ fieldsString.append(",");
+ valueString.append(",");
+ }
+ }
+ this.setPrimaryKeyVal(primaryKey);
+ if(primaryKey == null || primaryKey.length() <= 0) {
+ logger.error(EELFLoggerDelegate.errorLogger, "Some required partition key parts are missing: "+primaryKeyName );
+ //return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.SYNTAXERROR).setError("Some required partition key parts are missing: "+primaryKeyName).toMap()).build();
+ throw new MusicQueryException("Some required partition key parts are missing: " + primaryKeyName,
+ Status.BAD_REQUEST.getStatusCode());
+ }
+
+ fieldsString.replace(fieldsString.length()-1, fieldsString.length(), ")");
+ valueString.replace(valueString.length()-1, valueString.length(), ")");
+
+ queryObject.appendQueryString("INSERT INTO " + this.getKeyspaceName() + "." + this.getTableName() + " "
+ + fieldsString + " VALUES " + valueString);
+
+ String ttl = this.getTtl();
+ String timestamp = this.getTimestamp();
+
+ if ((ttl != null) && (timestamp != null)) {
+ logger.info(EELFLoggerDelegate.applicationLogger, "both there");
+ queryObject.appendQueryString(" USING TTL ? AND TIMESTAMP ?");
+ queryObject.addValue(Integer.parseInt(ttl));
+ queryObject.addValue(Long.parseLong(timestamp));
+ }
+
+ if ((ttl != null) && (timestamp == null)) {
+ logger.info(EELFLoggerDelegate.applicationLogger, "ONLY TTL there");
+ queryObject.appendQueryString(" USING TTL ?");
+ queryObject.addValue(Integer.parseInt(ttl));
+ }
+
+ if ((ttl == null) && (timestamp != null)) {
+ logger.info(EELFLoggerDelegate.applicationLogger, "ONLY timestamp there");
+ queryObject.appendQueryString(" USING TIMESTAMP ?");
+ queryObject.addValue(Long.parseLong(timestamp));
+ }
+
+ queryObject.appendQueryString(";");
+
+ ReturnType result = null;
+ String consistency = this.getConsistencyInfo().get("type");
+ if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL) && this.getConsistencyInfo().get("consistency") != null) {
+ if(MusicUtil.isValidConsistency(this.getConsistencyInfo().get("consistency"))) {
+ queryObject.setConsistency(this.getConsistencyInfo().get("consistency"));
+ } else {
+ // return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.SYNTAXERROR).setError("Invalid Consistency type").toMap()).build();
+ throw new MusicQueryException("Invalid Consistency type", Status.BAD_REQUEST.getStatusCode());
+ }
+ }
+ queryObject.setOperation("insert");
+
+ logger.info("Data insert Query ::::: " + queryObject.getQuery());
+
+ return queryObject;
+ }
+
+ /**
+ *
+ * @param rowParams
+ * @return
+ * @throws MusicQueryException
+ */
+ public PreparedQueryObject genSelectCriticalPreparedQueryObj(MultivaluedMap<String, String> rowParams) throws MusicQueryException {
+
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+
+ if((this.getKeyspaceName() == null || this.getKeyspaceName().isEmpty())
+ || (this.getTableName() == null || this.getTableName().isEmpty())){
+ /* return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
+ .setError("one or more path parameters are not set, please check and try again")
+ .toMap()).build();*/
+ throw new MusicQueryException("one or more path parameters are not set, please check and try again",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+ EELFLoggerDelegate.mdcPut("keyspace", "( "+this.getKeyspaceName()+" ) ");
+ RowIdentifier rowId = null;
+ try {
+ rowId = getRowIdentifier(this.getKeyspaceName(), this.getTableName(), rowParams, queryObject);
+ this.setPrimaryKeyVal(rowId.primarKeyValue);
+ } catch (MusicServiceException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes
+ .GENERALSERVICEERROR, ex);
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();*/
+ throw new MusicQueryException(ex.getMessage(), Status.BAD_REQUEST.getStatusCode());
+ }
+
+ queryObject.appendQueryString(
+ "SELECT * FROM " + this.getKeyspaceName() + "." + this.getTableName() + " WHERE " + rowId.rowIdString + ";");
+
+ return queryObject;
+ }
+
+ private class RowIdentifier {
+ public String primarKeyValue;
+ public StringBuilder rowIdString;
+ @SuppressWarnings("unused")
+ public PreparedQueryObject queryObject; // the string with all the row
+ // identifiers separated by AND
+
+ public RowIdentifier(String primaryKeyValue, StringBuilder rowIdString,
+ PreparedQueryObject queryObject) {
+ this.primarKeyValue = primaryKeyValue;
+ this.rowIdString = rowIdString;
+ this.queryObject = queryObject;
+ }
+ }
+
+ /**
+ *
+ * @param keyspace
+ * @param tablename
+ * @param rowParams
+ * @param queryObject
+ * @return
+ * @throws MusicServiceException
+ */
+ private RowIdentifier getRowIdentifier(String keyspace, String tablename,
+ MultivaluedMap<String, String> rowParams, PreparedQueryObject queryObject)
+ throws MusicServiceException {
+ StringBuilder rowSpec = new StringBuilder();
+ int counter = 0;
+ TableMetadata tableInfo = MusicDataStoreHandle.returnColumnMetadata(keyspace, tablename);
+ if (tableInfo == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,
+ "Table information not found. Please check input for table name= "
+ + keyspace + "." + tablename);
+ throw new MusicServiceException(
+ "Table information not found. Please check input for table name= "
+ + keyspace + "." + tablename);
+ }
+ StringBuilder primaryKey = new StringBuilder();
+ for (MultivaluedMap.Entry<String, List<String>> entry : rowParams.entrySet()) {
+ String keyName = entry.getKey();
+ List<String> valueList = entry.getValue();
+ String indValue = valueList.get(0);
+ DataType colType = null;
+ Object formattedValue = null;
+ try {
+ colType = tableInfo.getColumn(entry.getKey()).getType();
+ formattedValue = MusicUtil.convertToActualDataType(colType, indValue);
+ } catch (Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e);
+ }
+ if(tableInfo.getPrimaryKey().get(0).getName().equals(entry.getKey())) {
+ primaryKey.append(indValue);
+ }
+ rowSpec.append(keyName + "= ?");
+ queryObject.addValue(formattedValue);
+ if (counter != rowParams.size() - 1) {
+ rowSpec.append(" AND ");
+ }
+ counter = counter + 1;
+ }
+ return new RowIdentifier(primaryKey.toString(), rowSpec, queryObject);
+ }
+
}
* ===================================================================
* Copyright (c) 2017 AT&T Intellectual Property
* ===================================================================
+ * Modifications Copyright (C) 2019 IBM
+ * ===================================================================
* 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
import java.util.Map;
+import javax.ws.rs.core.Response.Status;
+
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.eelf.logging.EELFLoggerDelegate;
+import org.onap.music.eelf.logging.format.AppMessages;
+import org.onap.music.eelf.logging.format.ErrorSeverity;
+import org.onap.music.eelf.logging.format.ErrorTypes;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.main.MusicUtil;
+
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.swagger.annotations.ApiModel;
@ApiModel(value = "JsonTable", description = "Json model creating new keyspace")
@JsonIgnoreProperties(ignoreUnknown = true)
public class JsonKeySpace {
+ private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(JsonKeySpace.class);
private String keyspaceName;
private Map<String, Object> replicationInfo;
private String durabilityOfWrites;
this.keyspaceName = keyspaceName;
}
+ /**
+ * Will generate query to create Keyspacce.
+ *
+ * @throws MusicQueryException
+ */
+ @SuppressWarnings("deprecation")
+ public PreparedQueryObject genCreateKeyspaceQuery() throws MusicQueryException {
+
+ if (logger.isDebugEnabled()) {
+ logger.debug("Came inside createKeyspace method");
+ }
+
+ String keyspaceName = this.getKeyspaceName();
+ String durabilityOfWrites = this.getDurabilityOfWrites();
+ String consistency = MusicUtil.EVENTUAL;
+
+ logger.info("genCreateKeyspaceQuery keyspaceName ::" + keyspaceName);
+ logger.info("genCreateKeyspaceQuery class :: " + this.getReplicationInfo().get("class"));
+ logger.info("genCreateKeyspaceQuery replication_factor :: " + this.getReplicationInfo().get("replication_factor"));
+ logger.info("genCreateKeyspaceQuery durabilityOfWrites :: " + durabilityOfWrites);
+
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+
+ if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL) && this.getConsistencyInfo().get("consistency") != null) {
+ if(MusicUtil.isValidConsistency(this.getConsistencyInfo().get("consistency"))) {
+ queryObject.setConsistency(this.getConsistencyInfo().get("consistency"));
+ }else {
+ throw new MusicQueryException("Invalid Consistency type",Status.BAD_REQUEST.getStatusCode());
+ }
+ }
+
+ long start = System.currentTimeMillis();
+ Map<String, Object> replicationInfo = this.getReplicationInfo();
+ String repString = null;
+ try {
+ repString = "{" + MusicUtil.jsonMaptoSqlString(replicationInfo, ",") + "}";
+ } catch (Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(), AppMessages.MISSINGDATA,
+ ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
+ }
+ queryObject.appendQueryString("CREATE KEYSPACE " + keyspaceName + " WITH replication = " + repString);
+ if (this.getDurabilityOfWrites() != null) {
+ queryObject.appendQueryString(" AND durable_writes = " + this.getDurabilityOfWrites());
+ }
+ queryObject.appendQueryString(";");
+ long end = System.currentTimeMillis();
+ logger.info(EELFLoggerDelegate.applicationLogger,
+ "Time taken for setting up query in create keyspace:" + (end - start));
+
+ return queryObject;
+ }
+
+ /**
+ * Will generate Query to drop a keyspace.
+ *
+ * @return
+ */
+ public PreparedQueryObject genDropKeyspaceQuery() {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Coming inside genDropKeyspaceQuery method "+this.getKeyspaceName());
+ }
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+ queryObject.appendQueryString("DROP KEYSPACE " + this.getKeyspaceName() + ";");
+
+ return queryObject;
+ }
+
+ @Override
+ public String toString() {
+ return "CassaKeyspaceObject [keyspaceName=" + keyspaceName + ", replicationInfo=" + replicationInfo
+ + "durabilityOfWrites=" + durabilityOfWrites + "]";
+ }
}
* org.onap.music
* ===================================================================
* Copyright (c) 2017 AT&T Intellectual Property
- * Modifications Copyright (C) 2018 IBM.
+ * Modifications Copyright (C) 2019 IBM
* ===================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
+import java.util.List;
import java.util.Map;
-import org.onap.music.authentication.AuthUtil;
+
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response.Status;
+
+import org.onap.music.datastore.MusicDataStoreHandle;
+import org.onap.music.datastore.PreparedQueryObject;
import org.onap.music.eelf.logging.EELFLoggerDelegate;
+import org.onap.music.eelf.logging.format.AppMessages;
+import org.onap.music.eelf.logging.format.ErrorSeverity;
+import org.onap.music.eelf.logging.format.ErrorTypes;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.main.MusicUtil;
+
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.TableMetadata;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@JsonIgnoreProperties(ignoreUnknown = true)
public class JsonSelect implements Serializable {
private Map<String, String> consistencyInfo;
+ private String keyspaceName;
+ private String tableName;
private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(JsonSelect.class);
public void setConsistencyInfo(Map<String, String> consistencyInfo) {
this.consistencyInfo = consistencyInfo;
}
+
+ public String getKeyspaceName() {
+ return keyspaceName;
+ }
+
+ public void setKeyspaceName(String keyspaceName) {
+ this.keyspaceName = keyspaceName;
+ }
+
+ public String getTableName() {
+ return tableName;
+ }
+
+ public void setTableName(String tableName) {
+ this.tableName = tableName;
+ }
public byte[] serialize() {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
}
return bos.toByteArray();
}
+
+ /**
+ * genSelectQuery
+ *
+ * @return
+ * @throws MusicQueryException
+ */
+ public PreparedQueryObject genSelectQuery(MultivaluedMap<String, String> rowParams) throws MusicQueryException {
+
+ if((this.getKeyspaceName() == null || this.getKeyspaceName().isEmpty())
+ || (this.getTableName() == null || this.getTableName().isEmpty())){
+ throw new MusicQueryException("one or more path parameters are not set, please check and try again",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+ EELFLoggerDelegate.mdcPut("keyspace", "( " + this.getKeyspaceName() + " ) ");
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+
+ if (rowParams.isEmpty()) { // select all
+ queryObject.appendQueryString("SELECT * FROM " + this.getKeyspaceName() + "." + this.getTableName() + ";");
+ } else {
+ int limit = -1; // do not limit the number of results
+ try {
+ queryObject = selectSpecificQuery(this.getKeyspaceName(), this.getTableName(), rowParams, limit);
+ } catch (MusicServiceException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger, ex, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN,
+ ErrorTypes.GENERALSERVICEERROR, ex);
+
+ throw new MusicQueryException(ex.getMessage(), Status.BAD_REQUEST.getStatusCode());
+ }
+ }
+
+ return queryObject;
+ }
+
+ public PreparedQueryObject selectSpecificQuery(String keyspace,
+ String tablename, MultivaluedMap<String, String> rowParams, int limit)
+ throws MusicServiceException {
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+ StringBuilder rowIdString = getRowIdentifier(keyspace,
+ tablename,rowParams,queryObject).rowIdString;
+ queryObject.appendQueryString(
+ "SELECT * FROM " + keyspace + "." + tablename + " WHERE " + rowIdString);
+ if (limit != -1) {
+ queryObject.appendQueryString(" LIMIT " + limit);
+ }
+ queryObject.appendQueryString(";");
+ return queryObject;
+ }
+
+ private class RowIdentifier {
+ public String primarKeyValue;
+ public StringBuilder rowIdString;
+ @SuppressWarnings("unused")
+ public PreparedQueryObject queryObject; // the string with all the row
+ // identifiers separated by AND
+
+ public RowIdentifier(String primaryKeyValue, StringBuilder rowIdString,
+ PreparedQueryObject queryObject) {
+ this.primarKeyValue = primaryKeyValue;
+ this.rowIdString = rowIdString;
+ this.queryObject = queryObject;
+ }
+ }
+
+ /**
+ *
+ * @param keyspace
+ * @param tablename
+ * @param rowParams
+ * @param queryObject
+ * @return
+ * @throws MusicServiceException
+ */
+ private RowIdentifier getRowIdentifier(String keyspace, String tablename,
+ MultivaluedMap<String, String> rowParams, PreparedQueryObject queryObject)
+ throws MusicServiceException {
+ StringBuilder rowSpec = new StringBuilder();
+ int counter = 0;
+ TableMetadata tableInfo = MusicDataStoreHandle.returnColumnMetadata(keyspace, tablename);
+ if (tableInfo == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,
+ "Table information not found. Please check input for table name= "
+ + keyspace + "." + tablename);
+ throw new MusicServiceException(
+ "Table information not found. Please check input for table name= "
+ + keyspace + "." + tablename);
+ }
+ StringBuilder primaryKey = new StringBuilder();
+ for (MultivaluedMap.Entry<String, List<String>> entry : rowParams.entrySet()) {
+ String keyName = entry.getKey();
+ List<String> valueList = entry.getValue();
+ String indValue = valueList.get(0);
+ DataType colType = null;
+ Object formattedValue = null;
+ try {
+ colType = tableInfo.getColumn(entry.getKey()).getType();
+ formattedValue = MusicUtil.convertToActualDataType(colType, indValue);
+ } catch (Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e);
+ }
+ if(tableInfo.getPrimaryKey().get(0).getName().equals(entry.getKey())) {
+ primaryKey.append(indValue);
+ }
+ rowSpec.append(keyName + "= ?");
+ queryObject.addValue(formattedValue);
+ if (counter != rowParams.size() - 1) {
+ rowSpec.append(" AND ");
+ }
+ counter = counter + 1;
+ }
+ return new RowIdentifier(primaryKey.toString(), rowSpec, queryObject);
+ }
}
* ===================================================================
* Copyright (c) 2017 AT&T Intellectual Property
* ===================================================================
+ * Modifications Copyright (C) 2019 IBM
+ * ===================================================================
* 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
import java.util.Map;
+import javax.ws.rs.core.Response.Status;
+
+import org.apache.commons.lang3.StringUtils;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.eelf.logging.EELFLoggerDelegate;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.main.MusicUtil;
+
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.swagger.annotations.ApiModel;
@ApiModel(value = "JsonTable", description = "Defines the Json for Creating a new Table.")
@JsonIgnoreProperties(ignoreUnknown = true)
public class JsonTable {
+ private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(JsonTable.class);
+
private String keyspaceName;
private String tableName;
public void setPartitionKey(String partitionKey) {
this.partitionKey = partitionKey;
}
+
+ public PreparedQueryObject genCreateTableQuery() throws MusicQueryException {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Coming inside genCreateTableQuery method " + this.getKeyspaceName());
+ logger.debug("Coming inside genCreateTableQuery method " + this.getTableName());
+ }
+
+ String primaryKey = null;
+ String partitionKey = this.getPartitionKey();
+ String clusterKey = this.getClusteringKey();
+ String filteringKey = this.getFilteringKey();
+ if (filteringKey != null) {
+ clusterKey = clusterKey + "," + filteringKey;
+ }
+ primaryKey = this.getPrimaryKey(); // get primaryKey if available
+
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+ // first read the information about the table fields
+ Map<String, String> fields = this.getFields();
+ if (fields == null) {
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
+ .setError("Create Table Error: No fields in request").toMap()).build();*/
+ throw new MusicQueryException(
+ "Create Table Error: No fields in request", Status.BAD_REQUEST.getStatusCode());
+ }
+ StringBuilder fieldsString = new StringBuilder("(vector_ts text,");
+ int counter = 0;
+ for (Map.Entry<String, String> entry : fields.entrySet()) {
+ if (entry.getKey().equals("PRIMARY KEY")) {
+ primaryKey = entry.getValue(); // replaces primaryKey
+ primaryKey = primaryKey.trim();
+ } else {
+ if (counter == 0 ) fieldsString.append("" + entry.getKey() + " " + entry.getValue() + "");
+ else fieldsString.append("," + entry.getKey() + " " + entry.getValue() + "");
+ }
+
+ if (counter != (fields.size() - 1) ) {
+ counter = counter + 1;
+ } else {
+
+ if((primaryKey != null) && (partitionKey == null)) {
+ primaryKey = primaryKey.trim();
+ int count1 = StringUtils.countMatches(primaryKey, ')');
+ int count2 = StringUtils.countMatches(primaryKey, '(');
+ if (count1 != count2) {
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
+ .setError("Create Table Error: primary key '(' and ')' do not match, primary key=" + primaryKey)
+ .toMap()).build();*/
+ throw new MusicQueryException(
+ "Create Table Error: primary key '(' and ')' do not match, primary key=" + primaryKey,
+ Status.BAD_REQUEST.getStatusCode());
+ }
+
+ if ( primaryKey.indexOf('(') == -1 || ( count2 == 1 && (primaryKey.lastIndexOf(')') +1) == primaryKey.length() ) ) {
+ if (primaryKey.contains(",") ) {
+ partitionKey= primaryKey.substring(0,primaryKey.indexOf(','));
+ partitionKey=partitionKey.replaceAll("[\\(]+","");
+ clusterKey=primaryKey.substring(primaryKey.indexOf(',')+1); // make sure index
+ clusterKey=clusterKey.replaceAll("[)]+", "");
+ } else {
+ partitionKey=primaryKey;
+ partitionKey=partitionKey.replaceAll("[\\)]+","");
+ partitionKey=partitionKey.replaceAll("[\\(]+","");
+ clusterKey="";
+ }
+ } else { // not null and has ) before the last char
+ partitionKey= primaryKey.substring(0,primaryKey.indexOf(')'));
+ partitionKey=partitionKey.replaceAll("[\\(]+","");
+ partitionKey = partitionKey.trim();
+ clusterKey= primaryKey.substring(primaryKey.indexOf(')'));
+ clusterKey=clusterKey.replaceAll("[\\(]+","");
+ clusterKey=clusterKey.replaceAll("[\\)]+","");
+ clusterKey = clusterKey.trim();
+ if (clusterKey.indexOf(',') == 0) {
+ clusterKey=clusterKey.substring(1);
+ }
+ clusterKey = clusterKey.trim();
+ if (clusterKey.equals(",") ) clusterKey=""; // print error if needed ( ... ),)
+ }
+
+ if (!(partitionKey.isEmpty() || clusterKey.isEmpty())
+ && (partitionKey.equalsIgnoreCase(clusterKey) ||
+ clusterKey.contains(partitionKey) || partitionKey.contains(clusterKey)) ) {
+ logger.error("DataAPI createTable partition/cluster key ERROR: partitionKey="+partitionKey+", clusterKey=" + clusterKey + " and primary key=" + primaryKey );
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(
+ "Create Table primary key error: clusterKey(" + clusterKey + ") equals/contains/overlaps partitionKey(" +partitionKey+ ") of"
+ + " primary key=" + primaryKey)
+ .toMap()).build();*/
+ throw new MusicQueryException("Create Table primary key error: clusterKey(" + clusterKey
+ + ") equals/contains/overlaps partitionKey(" + partitionKey + ") of" + " primary key="
+ + primaryKey, Status.BAD_REQUEST.getStatusCode());
+
+ }
+
+ if (partitionKey.isEmpty() ) primaryKey="";
+ else if (clusterKey.isEmpty() ) primaryKey=" (" + partitionKey + ")";
+ else primaryKey=" (" + partitionKey + ")," + clusterKey;
+
+
+ if (primaryKey != null) fieldsString.append(", PRIMARY KEY (" + primaryKey + " )");
+
+ } else { // end of length > 0
+
+ if (!(partitionKey.isEmpty() || clusterKey.isEmpty())
+ && (partitionKey.equalsIgnoreCase(clusterKey) ||
+ clusterKey.contains(partitionKey) || partitionKey.contains(clusterKey)) ) {
+ logger.error("DataAPI createTable partition/cluster key ERROR: partitionKey="+partitionKey+", clusterKey=" + clusterKey);
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(
+ "Create Table primary key error: clusterKey(" + clusterKey + ") equals/contains/overlaps partitionKey(" +partitionKey+ ")")
+ .toMap()).build();*/
+ throw new MusicQueryException(
+ "Create Table primary key error: clusterKey(" + clusterKey
+ + ") equals/contains/overlaps partitionKey(" + partitionKey + ")",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+
+ if (partitionKey.isEmpty() ) primaryKey="";
+ else if (clusterKey.isEmpty() ) primaryKey=" (" + partitionKey + ")";
+ else primaryKey=" (" + partitionKey + ")," + clusterKey;
+
+ if (primaryKey != null) fieldsString.append(", PRIMARY KEY (" + primaryKey + " )");
+ }
+ fieldsString.append(")");
+
+ } // end of last field check
+
+ } // end of for each
+ // information about the name-value style properties
+ Map<String, Object> propertiesMap = this.getProperties();
+ StringBuilder propertiesString = new StringBuilder();
+ if (propertiesMap != null) {
+ counter = 0;
+ for (Map.Entry<String, Object> entry : propertiesMap.entrySet()) {
+ Object ot = entry.getValue();
+ String value = ot + "";
+ if (ot instanceof String) {
+ value = "'" + value + "'";
+ } else if (ot instanceof Map) {
+ @SuppressWarnings("unchecked")
+ Map<String, Object> otMap = (Map<String, Object>) ot;
+ try {
+ value = "{" + MusicUtil.jsonMaptoSqlString(otMap, ",") + "}";
+ } catch (Exception e) {
+ throw new MusicQueryException(e.getMessage(),
+ Status.BAD_REQUEST.getStatusCode());
+ }
+ }
+
+ propertiesString.append(entry.getKey() + "=" + value + "");
+ if (counter != propertiesMap.size() - 1)
+ propertiesString.append(" AND ");
+
+ counter = counter + 1;
+ }
+ }
+
+ String clusteringOrder = this.getClusteringOrder();
+
+ if (clusteringOrder != null && !(clusteringOrder.isEmpty())) {
+ String[] arrayClusterOrder = clusteringOrder.split("[,]+");
+
+ for (int i = 0; i < arrayClusterOrder.length; i++) {
+ String[] clusterS = arrayClusterOrder[i].trim().split("[ ]+");
+ if ( (clusterS.length ==2) && (clusterS[1].equalsIgnoreCase("ASC") || clusterS[1].equalsIgnoreCase("DESC"))) {
+ continue;
+ } else {
+ /*return response.status(Status.BAD_REQUEST)
+ .entity(new JsonResponse(ResultType.FAILURE)
+ .setError("createTable/Clustering Order vlaue ERROR: valid clustering order is ASC or DESC or expecting colname order; please correct clusteringOrder:"+ clusteringOrder+".")
+ .toMap()).build();*/
+
+ throw new MusicQueryException(
+ "createTable/Clustering Order vlaue ERROR: valid clustering order is ASC or DESC or expecting colname order; please correct clusteringOrder:"
+ + clusteringOrder + ".",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+ // add validation for column names in cluster key
+ }
+
+ if (!(clusterKey.isEmpty())) {
+ clusteringOrder = "CLUSTERING ORDER BY (" +clusteringOrder +")";
+ //cjc check if propertiesString.length() >0 instead propertiesMap
+ if (propertiesMap != null) {
+ propertiesString.append(" AND "+ clusteringOrder);
+ } else {
+ propertiesString.append(clusteringOrder);
+ }
+ } else {
+ logger.warn("Skipping clustering order=("+clusteringOrder+ ") since clustering key is empty ");
+ }
+ } //if non empty
+
+ queryObject.appendQueryString(
+ "CREATE TABLE " + this.getKeyspaceName() + "." + this.getTableName() + " " + fieldsString);
+
+
+ if (propertiesString != null && propertiesString.length()>0 )
+ queryObject.appendQueryString(" WITH " + propertiesString);
+ queryObject.appendQueryString(";");
+
+ return queryObject;
+ }
+
+ /**
+ *
+ * @return
+ */
+ public PreparedQueryObject genCreateShadowLockingTableQuery() {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Coming inside genCreateShadowLockingTableQuery method " + this.getKeyspaceName());
+ logger.debug("Coming inside genCreateShadowLockingTableQuery method " + this.getTableName());
+ }
+
+ String tableName = "unsyncedKeys_" + this.getTableName();
+ String tabQuery = "CREATE TABLE IF NOT EXISTS " + this.getKeyspaceName() + "." + tableName
+ + " ( key text,PRIMARY KEY (key) );";
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+ queryObject.appendQueryString(tabQuery);
+
+ return queryObject;
+ }
+
+ /**
+ * genDropTableQuery
+ *
+ * @return PreparedQueryObject
+ */
+ public PreparedQueryObject genDropTableQuery() {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Coming inside genDropTableQuery method " + this.getKeyspaceName());
+ logger.debug("Coming inside genDropTableQuery method " + this.getTableName());
+ }
+
+ PreparedQueryObject query = new PreparedQueryObject();
+ query.appendQueryString("DROP TABLE " + this.getKeyspaceName() + "." + this.getTableName() + ";");
+ logger.info("Delete Query ::::: " + query.getQuery());
+
+ return query;
+ }
}
* org.onap.music
* ===================================================================
* Copyright (c) 2017 AT&T Intellectual Property
- * Modifications Copyright (C) 2018 IBM.
+ * Modifications Copyright (C) 2019 IBM
* ===================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
+import java.util.List;
import java.util.Map;
+import java.util.UUID;
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response.Status;
+import org.onap.music.datastore.Condition;
+import org.onap.music.datastore.MusicDataStoreHandle;
+import org.onap.music.datastore.PreparedQueryObject;
import org.onap.music.eelf.logging.EELFLoggerDelegate;
import org.onap.music.eelf.logging.format.AppMessages;
import org.onap.music.eelf.logging.format.ErrorSeverity;
import org.onap.music.eelf.logging.format.ErrorTypes;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.main.MusicUtil;
+import org.onap.music.main.ReturnType;
+
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.TableMetadata;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
@ApiModel(value = "JsonTable", description = "Json model for table update")
@JsonIgnoreProperties(ignoreUnknown = true)
private Map<String, String> consistencyInfo;
private transient Map<String, Object> conditions;
private transient Map<String, Object> rowSpecification;
+ private StringBuilder rowIdString;
+ private String primarKeyValue;
private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(JsonUpdate.class);
@ApiModelProperty(value = "Conditions")
public void setValues(Map<String, Object> values) {
this.values = values;
}
+
+ public StringBuilder getRowIdString() {
+ return rowIdString;
+ }
+
+ public void setRowIdString(StringBuilder rowIdString) {
+ this.rowIdString = rowIdString;
+ }
+
+ public String getPrimarKeyValue() {
+ return primarKeyValue;
+ }
+
+ public void setPrimarKeyValue(String primarKeyValue) {
+ this.primarKeyValue = primarKeyValue;
+ }
public byte[] serialize() {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
}
return bos.toByteArray();
}
+
+ /**
+ * Generate TableInsertQuery
+ * @return
+ * @throws MusicQueryException
+ */
+ public PreparedQueryObject genUpdatePreparedQueryObj(MultivaluedMap<String, String> rowParams) throws MusicQueryException {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Coming inside genUpdatePreparedQueryObj method " + this.getKeyspaceName());
+ logger.debug("Coming inside genUpdatePreparedQueryObj method " + this.getTableName());
+ }
+
+ PreparedQueryObject queryObject = new PreparedQueryObject();
+
+ if((this.getKeyspaceName() == null || this.getKeyspaceName().isEmpty()) ||
+ (this.getTableName() == null || this.getTableName().isEmpty())){
+
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
+ .setError("one or more path parameters are not set, please check and try again")
+ .toMap()).build();*/
+
+ throw new MusicQueryException("one or more path parameters are not set, please check and try again",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+
+ EELFLoggerDelegate.mdcPut("keyspace", "( "+this.getKeyspaceName()+" ) ");
+ long startTime = System.currentTimeMillis();
+ String operationId = UUID.randomUUID().toString(); // just for infoging purposes.
+ String consistency = this.getConsistencyInfo().get("type");
+
+ logger.info(EELFLoggerDelegate.applicationLogger, "--------------Music " + consistency
+ + " update-" + operationId + "-------------------------");
+ // obtain the field value pairs of the update
+
+ Map<String, Object> valuesMap = this.getValues();
+
+ TableMetadata tableInfo;
+
+ try {
+ tableInfo = MusicDataStoreHandle.returnColumnMetadata(this.getKeyspaceName(), this.getTableName());
+ } catch (MusicServiceException e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes
+ .GENERALSERVICEERROR, e);
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();*/
+ throw new MusicQueryException(e.getMessage(), Status.BAD_REQUEST.getStatusCode());
+ }catch (Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger, e, AppMessages.UNKNOWNERROR, ErrorSeverity.CRITICAL,
+ ErrorTypes.GENERALSERVICEERROR);
+ throw new MusicQueryException(e.getMessage(), Status.BAD_REQUEST.getStatusCode());
+ }
+
+ if (tableInfo == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,"Table information not found. Please check input for table name= "+this.getTableName(), AppMessages.MISSINGINFO ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
+
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
+ .setError("Table information not found. Please check input for table name= "
+ + this.getKeyspaceName() + "." + this.getTableName()).toMap()).build();*/
+
+ throw new MusicQueryException("Table information not found. Please check input for table name= "
+ + this.getKeyspaceName() + "." + this.getTableName(), Status.BAD_REQUEST.getStatusCode());
+ }
+
+ String vectorTs = String.valueOf(Thread.currentThread().getId() + System.currentTimeMillis());
+ StringBuilder fieldValueString = new StringBuilder("vector_ts=?,");
+ queryObject.addValue(vectorTs);
+ int counter = 0;
+ for (Map.Entry<String, Object> entry : valuesMap.entrySet()) {
+ Object valueObj = entry.getValue();
+ DataType colType = null;
+ try {
+ colType = tableInfo.getColumn(entry.getKey()).getType();
+ } catch(NullPointerException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger, ex, "Invalid column name : "+entry.getKey(), ex);
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).
+ * setError("Invalid column name : "+entry.getKey()).toMap()).build();*/
+
+ throw new MusicQueryException("Invalid column name : " + entry.getKey(),Status.BAD_REQUEST.getStatusCode());
+ }
+ Object valueString = null;
+ try {
+ valueString = MusicUtil.convertToActualDataType(colType, valueObj);
+ } catch (Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e);
+ }
+ fieldValueString.append(entry.getKey() + "= ?");
+ queryObject.addValue(valueString);
+ if (counter != valuesMap.size() - 1) {
+ fieldValueString.append(",");
+ }
+ counter = counter + 1;
+ }
+ String ttl = this.getTtl();
+ String timestamp = this.getTimestamp();
+
+ queryObject.appendQueryString("UPDATE " + this.getKeyspaceName() + "." + this.getTableName() + " ");
+ if ((ttl != null) && (timestamp != null)) {
+ logger.info("both there");
+ queryObject.appendQueryString(" USING TTL ? AND TIMESTAMP ?");
+ queryObject.addValue(Integer.parseInt(ttl));
+ queryObject.addValue(Long.parseLong(timestamp));
+ }
+
+ if ((ttl != null) && (timestamp == null)) {
+ logger.info("ONLY TTL there");
+ queryObject.appendQueryString(" USING TTL ?");
+ queryObject.addValue(Integer.parseInt(ttl));
+ }
+
+ if ((ttl == null) && (timestamp != null)) {
+ logger.info("ONLY timestamp there");
+ queryObject.appendQueryString(" USING TIMESTAMP ?");
+ queryObject.addValue(Long.parseLong(timestamp));
+ }
+
+ // get the row specifier
+ RowIdentifier rowId = null;
+ try {
+ rowId = getRowIdentifier(this.getKeyspaceName(), this.getTableName(), rowParams, queryObject);
+ this.setRowIdString(rowId.rowIdString);
+ this.setPrimarKeyValue(rowId.primarKeyValue);
+ if(rowId == null || rowId.primarKeyValue.isEmpty()) {
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
+ .setError("Mandatory WHERE clause is missing. Please check the input request.").toMap()).build();*/
+
+ throw new MusicQueryException("Mandatory WHERE clause is missing. Please check the input request.",
+ Status.BAD_REQUEST.getStatusCode());
+ }
+ } catch (MusicQueryException ex) {
+ throw new MusicQueryException("Mandatory WHERE clause is missing. Please check the input request.",
+ Status.BAD_REQUEST.getStatusCode());
+
+ }catch (MusicServiceException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes
+ .GENERALSERVICEERROR, ex);
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();*/
+
+ throw new MusicQueryException(ex.getMessage(), Status.BAD_REQUEST.getStatusCode());
+
+ }
+
+
+
+ queryObject.appendQueryString(
+ " SET " + fieldValueString + " WHERE " + rowId.rowIdString + ";");
+
+
+
+ // get the conditional, if any
+ Condition conditionInfo;
+ if (this.getConditions() == null) {
+ conditionInfo = null;
+ } else {
+ // to avoid parsing repeatedly, just send the select query to obtain row
+ PreparedQueryObject selectQuery = new PreparedQueryObject();
+ selectQuery.appendQueryString("SELECT * FROM " + this.getKeyspaceName() + "." + this.getTableName() + " WHERE "
+ + rowId.rowIdString + ";");
+ selectQuery.addValue(rowId.primarKeyValue);
+ conditionInfo = new Condition(this.getConditions(), selectQuery);
+ }
+
+ ReturnType operationResult = null;
+ long jsonParseCompletionTime = System.currentTimeMillis();
+
+ if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL) && this.getConsistencyInfo().get("consistency") != null) {
+ if(MusicUtil.isValidConsistency(this.getConsistencyInfo().get("consistency"))) {
+ queryObject.setConsistency(this.getConsistencyInfo().get("consistency"));
+ } else {
+ /*return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.SYNTAXERROR)
+ .setError("Invalid Consistency type").toMap()).build();*/
+
+ logger.error("Invalid Consistency type");
+ throw new MusicQueryException("Invalid Consistency type", Status.BAD_REQUEST.getStatusCode());
+ }
+ }
+
+ queryObject.setOperation("update");
+
+ return queryObject;
+ }
+
+ private class RowIdentifier {
+ public String primarKeyValue;
+ public StringBuilder rowIdString;
+ @SuppressWarnings("unused")
+ public PreparedQueryObject queryObject; // the string with all the row
+ // identifiers separated by AND
+
+ public RowIdentifier(String primaryKeyValue, StringBuilder rowIdString,
+ PreparedQueryObject queryObject) {
+ this.primarKeyValue = primaryKeyValue;
+ this.rowIdString = rowIdString;
+ this.queryObject = queryObject;
+ }
+ }
+
+ /**
+ *
+ * @param keyspace
+ * @param tablename
+ * @param rowParams
+ * @param queryObject
+ * @return
+ * @throws MusicServiceException
+ */
+ private RowIdentifier getRowIdentifier(String keyspace, String tablename,
+ MultivaluedMap<String, String> rowParams, PreparedQueryObject queryObject)
+ throws MusicServiceException {
+ StringBuilder rowSpec = new StringBuilder();
+ int counter = 0;
+ TableMetadata tableInfo = MusicDataStoreHandle.returnColumnMetadata(keyspace, tablename);
+ if (tableInfo == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,
+ "Table information not found. Please check input for table name= "
+ + keyspace + "." + tablename);
+ throw new MusicServiceException(
+ "Table information not found. Please check input for table name= "
+ + keyspace + "." + tablename);
+ }
+ StringBuilder primaryKey = new StringBuilder();
+ for (MultivaluedMap.Entry<String, List<String>> entry : rowParams.entrySet()) {
+ String keyName = entry.getKey();
+ List<String> valueList = entry.getValue();
+ String indValue = valueList.get(0);
+ DataType colType = null;
+ Object formattedValue = null;
+ try {
+ colType = tableInfo.getColumn(entry.getKey()).getType();
+ formattedValue = MusicUtil.convertToActualDataType(colType, indValue);
+ } catch (Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e);
+ }
+ if(tableInfo.getPrimaryKey().get(0).getName().equals(entry.getKey())) {
+ primaryKey.append(indValue);
+ }
+ rowSpec.append(keyName + "= ?");
+ queryObject.addValue(formattedValue);
+ if (counter != rowParams.size() - 1) {
+ rowSpec.append(" AND ");
+ }
+ counter = counter + 1;
+ }
+ return new RowIdentifier(primaryKey.toString(), rowSpec, queryObject);
+ }
}
import java.util.List;
import java.util.Map;
+
+import javax.ws.rs.core.MultivaluedMap;
+
import org.onap.music.datastore.Condition;
import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.datastore.jsonobjects.JsonDelete;
+import org.onap.music.datastore.jsonobjects.JsonIndex;
+import org.onap.music.datastore.jsonobjects.JsonInsert;
+import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+import org.onap.music.datastore.jsonobjects.JsonSelect;
+import org.onap.music.datastore.jsonobjects.JsonTable;
+import org.onap.music.datastore.jsonobjects.JsonUpdate;
import org.onap.music.eelf.logging.EELFLoggerDelegate;
import org.onap.music.exceptions.MusicLockingException;
import org.onap.music.exceptions.MusicQueryException;
import org.onap.music.lockingservice.cassandra.LockType;
import org.onap.music.lockingservice.cassandra.MusicLockState;
import org.onap.music.service.MusicCoreService;
+
import com.datastax.driver.core.ResultSet;
public class MusicCore {
public static MusicLockState releaseLock(String lockId, boolean voluntaryRelease) throws MusicLockingException {
return musicCore.releaseLock(lockId, voluntaryRelease);
}
+
+ //Added changes for orm implementation.
+
+ public static ResultType createKeyspace(JsonKeySpace jsonKeySpaceObject, String consistencyInfo)
+ throws MusicServiceException, MusicQueryException {
+ return musicCore.createKeyspace(jsonKeySpaceObject,consistencyInfo);
+ }
+
+ public static ResultType dropKeyspace(JsonKeySpace josnKeyspaceObject, String consistencyInfo)
+ throws MusicServiceException,MusicQueryException {
+ return musicCore.dropKeyspace(josnKeyspaceObject, consistencyInfo);
+ }
+
+ public static ResultType createTable(JsonTable jsonTableObject,String consistencyInfo)
+ throws MusicServiceException,MusicQueryException {
+ return musicCore.createTable(jsonTableObject, consistencyInfo);
+ }
+
+ public static ResultType dropTable(JsonTable jsonTableObject, String consistencyInfo)
+ throws MusicServiceException, MusicQueryException {
+ return musicCore.dropTable(jsonTableObject, consistencyInfo);
+ }
+
+ public static ResultType createIndex(JsonIndex jsonIndexObject, String consistencyInfo)
+ throws MusicServiceException,MusicQueryException {
+ return musicCore.createIndex(jsonIndexObject, consistencyInfo);
+ }
+
+ public static ResultSet select(JsonSelect jsonSelect, MultivaluedMap<String, String> rowParams)
+ throws MusicServiceException, MusicQueryException{
+ return musicCore.select(jsonSelect, rowParams);
+ }
+
+ public static ResultSet selectCritical(JsonInsert jsonInsertObj, MultivaluedMap<String, String> rowParams)
+ throws MusicLockingException, MusicQueryException, MusicServiceException{
+ return musicCore.selectCritical(jsonInsertObj, rowParams);
+ }
+
+
+ public static ReturnType insertIntoTable(JsonInsert jsonInsert) throws MusicLockingException, MusicQueryException, MusicServiceException{
+ return musicCore.insertIntoTable(jsonInsert);
+ }
+
+ public static ReturnType updateTable(JsonUpdate jsonUpdateObj,MultivaluedMap<String, String> rowParams)
+ throws MusicLockingException, MusicQueryException, MusicServiceException{
+ return musicCore.updateTable(jsonUpdateObj, rowParams);
+ }
+
+ public static ReturnType deleteFromTable(JsonDelete jsonDeleteObj,MultivaluedMap<String, String> rowParams)
+ throws MusicLockingException, MusicQueryException, MusicServiceException{
+ return musicCore.deleteFromTable(jsonDeleteObj,rowParams);
+ }
* ===================================================================
* Modifications Copyright (c) 2019 Samsung
* ===================================================================
+ * Modifications Copyright (C) 2019 IBM
+ * ===================================================================
* 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
package org.onap.music.rest;
-import java.nio.ByteBuffer;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriInfo;
-import org.apache.commons.lang3.StringUtils;
+import org.onap.music.datastore.MusicDataStoreHandle;
import org.onap.music.datastore.PreparedQueryObject;
import org.onap.music.datastore.jsonobjects.JsonDelete;
+import org.onap.music.datastore.jsonobjects.JsonIndex;
import org.onap.music.datastore.jsonobjects.JsonInsert;
import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+import org.onap.music.datastore.jsonobjects.JsonSelect;
import org.onap.music.datastore.jsonobjects.JsonTable;
import org.onap.music.datastore.jsonobjects.JsonUpdate;
import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.exceptions.MusicLockingException;
-import org.onap.music.exceptions.MusicQueryException;
import org.onap.music.eelf.logging.format.AppMessages;
import org.onap.music.eelf.logging.format.ErrorSeverity;
import org.onap.music.eelf.logging.format.ErrorTypes;
+import org.onap.music.exceptions.MusicLockingException;
+import org.onap.music.exceptions.MusicQueryException;
import org.onap.music.exceptions.MusicServiceException;
import org.onap.music.main.MusicCore;
-import org.onap.music.datastore.Condition;
-import org.onap.music.datastore.MusicDataStoreHandle;
import org.onap.music.main.MusicUtil;
import org.onap.music.main.ResultType;
import org.onap.music.main.ReturnType;
import com.datastax.driver.core.TableMetadata;
import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiImplicitParam;
-import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
-import io.swagger.annotations.ApiResponses;
import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
import io.swagger.annotations.Example;
import io.swagger.annotations.ExampleProperty;
response.status(Status.BAD_REQUEST);
return response.entity(new JsonResponse(ResultType.FAILURE).setError(ResultType.BODYMISSING.getResult()).toMap()).build();
}
-
- String consistency = MusicUtil.EVENTUAL;// for now this needs only eventual consistency
-
- PreparedQueryObject queryObject = new PreparedQueryObject();
- if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL) && kspObject.getConsistencyInfo().get("consistency") != null) {
- if(MusicUtil.isValidConsistency(kspObject.getConsistencyInfo().get("consistency")))
- queryObject.setConsistency(kspObject.getConsistencyInfo().get("consistency"));
- else
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.SYNTAXERROR).setError("Invalid Consistency type").toMap()).build();
- }
- long start = System.currentTimeMillis();
- Map<String, Object> replicationInfo = kspObject.getReplicationInfo();
- String repString = null;
- try {
- repString = "{" + MusicUtil.jsonMaptoSqlString(replicationInfo, ",") + "}";
- } catch (Exception e) {
- logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.MISSINGDATA ,ErrorSeverity
- .CRITICAL, ErrorTypes.DATAERROR, e);
-
- }
- queryObject.appendQueryString(
- "CREATE KEYSPACE " + keyspaceName + " WITH replication = " + repString);
- if (kspObject.getDurabilityOfWrites() != null) {
- queryObject.appendQueryString(
- " AND durable_writes = " + kspObject.getDurabilityOfWrites());
- }
-
- queryObject.appendQueryString(";");
- long end = System.currentTimeMillis();
- logger.info(EELFLoggerDelegate.applicationLogger,
- "Time taken for setting up query in create keyspace:" + (end - start));
-
ResultType result = ResultType.FAILURE;
try {
- result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
+ kspObject.setKeyspaceName(keyspaceName);
+ result = MusicCore.createKeyspace(kspObject, MusicUtil.EVENTUAL);
+ logger.info(EELFLoggerDelegate.applicationLogger, "result = " + result);
} catch ( MusicQueryException ex) {
logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.QUERYERROR
,ErrorSeverity.WARN, ErrorTypes.QUERYERROR);
logger.info(EELFLoggerDelegate.applicationLogger,"In Drop Keyspace " + keyspaceName);
if (MusicUtil.isKeyspaceActive()) {
String consistency = MusicUtil.EVENTUAL;// for now this needs only
- PreparedQueryObject queryObject = new PreparedQueryObject();
- queryObject.appendQueryString("DROP KEYSPACE " + keyspaceName + ";");
String droperror = "Error Deleteing Keyspace " + keyspaceName;
+ JsonKeySpace kspObject = new JsonKeySpace();
+ kspObject.setKeyspaceName(keyspaceName);
try{
- ResultType result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
+ ResultType result = MusicCore.dropKeyspace(kspObject, consistency);
if ( result.equals(ResultType.FAILURE) ) {
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(result).setError(droperror).toMap()).build();
}
EELFLoggerDelegate.mdcPut("keyspace", "( "+keyspace+" ) ");
String consistency = MusicUtil.EVENTUAL;
// for now this needs only eventual consistency
- String primaryKey = null;
- String partitionKey = tableObj.getPartitionKey();
- String clusterKey = tableObj.getClusteringKey();
- String filteringKey = tableObj.getFilteringKey();
- if(filteringKey != null) {
- clusterKey = clusterKey + "," + filteringKey;
- }
- primaryKey = tableObj.getPrimaryKey(); // get primaryKey if available
-
- PreparedQueryObject queryObject = new PreparedQueryObject();
- // first read the information about the table fields
- Map<String, String> fields = tableObj.getFields();
- if (fields == null) {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
- .setError("Create Table Error: No fields in request").toMap()).build();
- }
-
- StringBuilder fieldsString = new StringBuilder("(vector_ts text,");
- int counter = 0;
- for (Map.Entry<String, String> entry : fields.entrySet()) {
- if (entry.getKey().equals("PRIMARY KEY")) {
- primaryKey = entry.getValue(); // replaces primaryKey
- primaryKey = primaryKey.trim();
- } else {
- if (counter == 0 ) fieldsString.append("" + entry.getKey() + " " + entry.getValue() + "");
- else fieldsString.append("," + entry.getKey() + " " + entry.getValue() + "");
- }
-
- if (counter != (fields.size() - 1) ) {
- counter = counter + 1;
- } else {
-
- if((primaryKey != null) && (partitionKey == null)) {
- primaryKey = primaryKey.trim();
- int count1 = StringUtils.countMatches(primaryKey, ')');
- int count2 = StringUtils.countMatches(primaryKey, '(');
- if (count1 != count2) {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
- .setError("Create Table Error: primary key '(' and ')' do not match, primary key=" + primaryKey)
- .toMap()).build();
- }
-
- if ( primaryKey.indexOf('(') == -1 || ( count2 == 1 && (primaryKey.lastIndexOf(')') +1) == primaryKey.length() ) ) {
- if (primaryKey.contains(",") ) {
- partitionKey= primaryKey.substring(0,primaryKey.indexOf(','));
- partitionKey=partitionKey.replaceAll("[\\(]+","");
- clusterKey=primaryKey.substring(primaryKey.indexOf(',')+1); // make sure index
- clusterKey=clusterKey.replaceAll("[)]+", "");
- } else {
- partitionKey=primaryKey;
- partitionKey=partitionKey.replaceAll("[\\)]+","");
- partitionKey=partitionKey.replaceAll("[\\(]+","");
- clusterKey="";
- }
- } else { // not null and has ) before the last char
- partitionKey= primaryKey.substring(0,primaryKey.indexOf(')'));
- partitionKey=partitionKey.replaceAll("[\\(]+","");
- partitionKey = partitionKey.trim();
- clusterKey= primaryKey.substring(primaryKey.indexOf(')'));
- clusterKey=clusterKey.replaceAll("[\\(]+","");
- clusterKey=clusterKey.replaceAll("[\\)]+","");
- clusterKey = clusterKey.trim();
- if (clusterKey.indexOf(',') == 0) {
- clusterKey=clusterKey.substring(1);
- }
- clusterKey = clusterKey.trim();
- if (clusterKey.equals(",") ) clusterKey=""; // print error if needed ( ... ),)
- }
-
- if (!(partitionKey.isEmpty() || clusterKey.isEmpty())
- && (partitionKey.equalsIgnoreCase(clusterKey) ||
- clusterKey.contains(partitionKey) || partitionKey.contains(clusterKey)) ) {
- logger.error("DataAPI createTable partition/cluster key ERROR: partitionKey="+partitionKey+", clusterKey=" + clusterKey + " and primary key=" + primaryKey );
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(
- "Create Table primary key error: clusterKey(" + clusterKey + ") equals/contains/overlaps partitionKey(" +partitionKey+ ") of"
- + " primary key=" + primaryKey)
- .toMap()).build();
-
- }
-
- if (partitionKey.isEmpty() ) primaryKey="";
- else if (clusterKey.isEmpty() ) primaryKey=" (" + partitionKey + ")";
- else primaryKey=" (" + partitionKey + ")," + clusterKey;
-
-
- if (primaryKey != null) fieldsString.append(", PRIMARY KEY (" + primaryKey + " )");
-
- } else { // end of length > 0
-
- if (!(partitionKey.isEmpty() || clusterKey.isEmpty())
- && (partitionKey.equalsIgnoreCase(clusterKey) ||
- clusterKey.contains(partitionKey) || partitionKey.contains(clusterKey)) ) {
- logger.error("DataAPI createTable partition/cluster key ERROR: partitionKey="+partitionKey+", clusterKey=" + clusterKey);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(
- "Create Table primary key error: clusterKey(" + clusterKey + ") equals/contains/overlaps partitionKey(" +partitionKey+ ")")
- .toMap()).build();
- }
-
- if (partitionKey.isEmpty() ) primaryKey="";
- else if (clusterKey.isEmpty() ) primaryKey=" (" + partitionKey + ")";
- else primaryKey=" (" + partitionKey + ")," + clusterKey;
-
- if (primaryKey != null) fieldsString.append(", PRIMARY KEY (" + primaryKey + " )");
- }
- fieldsString.append(")");
-
- } // end of last field check
-
- } // end of for each
- // information about the name-value style properties
- Map<String, Object> propertiesMap = tableObj.getProperties();
- StringBuilder propertiesString = new StringBuilder();
- if (propertiesMap != null) {
- counter = 0;
- for (Map.Entry<String, Object> entry : propertiesMap.entrySet()) {
- Object ot = entry.getValue();
- String value = ot + "";
- if (ot instanceof String) {
- value = "'" + value + "'";
- } else if (ot instanceof Map) {
- @SuppressWarnings("unchecked")
- Map<String, Object> otMap = (Map<String, Object>) ot;
- value = "{" + MusicUtil.jsonMaptoSqlString(otMap, ",") + "}";
- }
-
- propertiesString.append(entry.getKey() + "=" + value + "");
- if (counter != propertiesMap.size() - 1)
- propertiesString.append(" AND ");
-
- counter = counter + 1;
- }
- }
-
- String clusteringOrder = tableObj.getClusteringOrder();
-
- if (clusteringOrder != null && !(clusteringOrder.isEmpty())) {
- String[] arrayClusterOrder = clusteringOrder.split("[,]+");
-
- for (int i = 0; i < arrayClusterOrder.length; i++) {
- String[] clusterS = arrayClusterOrder[i].trim().split("[ ]+");
- if ( (clusterS.length ==2) && (clusterS[1].equalsIgnoreCase("ASC") || clusterS[1].equalsIgnoreCase("DESC"))) {
- continue;
- } else {
- return response.status(Status.BAD_REQUEST)
- .entity(new JsonResponse(ResultType.FAILURE)
- .setError("createTable/Clustering Order vlaue ERROR: valid clustering order is ASC or DESC or expecting colname order; please correct clusteringOrder:"+ clusteringOrder+".")
- .toMap()).build();
- }
- // add validation for column names in cluster key
- }
-
- if (!(clusterKey.isEmpty())) {
- clusteringOrder = "CLUSTERING ORDER BY (" +clusteringOrder +")";
- //cjc check if propertiesString.length() >0 instead propertiesMap
- if (propertiesMap != null) {
- propertiesString.append(" AND "+ clusteringOrder);
- } else {
- propertiesString.append(clusteringOrder);
- }
- } else {
- logger.warn("Skipping clustering order=("+clusteringOrder+ ") since clustering key is empty ");
- }
- } //if non empty
-
- queryObject.appendQueryString(
- "CREATE TABLE " + keyspace + "." + tablename + " " + fieldsString);
-
-
- if (propertiesString != null && propertiesString.length()>0 )
- queryObject.appendQueryString(" WITH " + propertiesString);
- queryObject.appendQueryString(";");
ResultType result = ResultType.FAILURE;
try {
- result = MusicCore.createTable(keyspace, tablename, queryObject, consistency);
+ tableObj.setKeyspaceName(keyspace);
+ tableObj.setTableName(tablename);
+ result = MusicCore.createTable(tableObj, consistency);
+ } catch (MusicQueryException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), ex.getMessage() ,ErrorSeverity
+ .WARN, ErrorTypes.MUSICSERVICEERROR, ex);
+ return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
} catch (MusicServiceException ex) {
logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity.CRITICAL, ErrorTypes.MUSICSERVICEERROR);
response.status(Status.BAD_REQUEST);
String indexName = "";
if (rowParams.getFirst("index_name") != null)
indexName = rowParams.getFirst("index_name");
- PreparedQueryObject query = new PreparedQueryObject();
- query.appendQueryString("Create index if not exists " + indexName + " on " + keyspace + "."
- + tablename + " (" + fieldName + ");");
-
+
+ JsonIndex jsonIndexObject = new JsonIndex(indexName, keyspace, tablename, fieldName);
+
ResultType result = ResultType.FAILURE;
try {
- result = MusicCore.nonKeyRelatedPut(query, "eventual");
+ result = MusicCore.createIndex(jsonIndexObject, MusicUtil.EVENTUAL);
} catch (MusicServiceException ex) {
logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity
.CRITICAL, ErrorTypes.GENERALSERVICEERROR, ex);
.toMap()).build();
}
EELFLoggerDelegate.mdcPut("keyspace","(" + keyspace + ")");
- PreparedQueryObject queryObject = new PreparedQueryObject();
- TableMetadata tableInfo = null;
- try {
- tableInfo = MusicDataStoreHandle.returnColumnMetadata(keyspace, tablename);
- if(tableInfo == null) {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("Table name doesn't exists. Please check the table name.").toMap()).build();
- }
- } catch (MusicServiceException e) {
- logger.error(EELFLoggerDelegate.errorLogger, e, AppMessages.UNKNOWNERROR ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();
- }
- String primaryKeyName = tableInfo.getPrimaryKey().get(0).getName();
- StringBuilder fieldsString = new StringBuilder("(vector_ts,");
- String vectorTs =
- String.valueOf(Thread.currentThread().getId() + System.currentTimeMillis());
- StringBuilder valueString = new StringBuilder("(" + "?" + ",");
- queryObject.addValue(vectorTs);
-
- Map<String, Object> valuesMap = insObj.getValues();
- if (valuesMap==null) {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
- .setError("Nothing to insert. No values provided in request.").toMap()).build();
- }
- int counter = 0;
- String primaryKey = "";
- for (Map.Entry<String, Object> entry : valuesMap.entrySet()) {
- fieldsString.append("" + entry.getKey());
- Object valueObj = entry.getValue();
- if (primaryKeyName.equals(entry.getKey())) {
- primaryKey = entry.getValue() + "";
- primaryKey = primaryKey.replace("'", "''");
- }
- DataType colType = null;
- try {
- colType = tableInfo.getColumn(entry.getKey()).getType();
- } catch(NullPointerException ex) {
- logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage() +" Invalid column name : "+entry.getKey
- (), AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR, ex);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("Invalid column name : "+entry.getKey()).toMap()).build();
- }
-
- Object formattedValue = null;
- try {
- formattedValue = MusicUtil.convertToActualDataType(colType, valueObj);
- } catch (Exception e) {
- logger.error(EELFLoggerDelegate.errorLogger,e);
- }
- valueString.append("?");
-
- queryObject.addValue(formattedValue);
-
- if (counter == valuesMap.size() - 1) {
- fieldsString.append(")");
- valueString.append(")");
- } else {
- fieldsString.append(",");
- valueString.append(",");
- }
- counter = counter + 1;
- }
-
- //blobs..
- Map<String, byte[]> objectMap = insObj.getObjectMap();
- if(objectMap != null) {
- for (Map.Entry<String, byte[]> entry : objectMap.entrySet()) {
- if(counter > 0) {
- fieldsString.replace(fieldsString.length()-1, fieldsString.length(), ",");
- valueString.replace(valueString.length()-1, valueString.length(), ",");
- }
- fieldsString.append("" + entry.getKey());
- byte[] valueObj = entry.getValue();
- if (primaryKeyName.equals(entry.getKey())) {
- primaryKey = entry.getValue() + "";
- primaryKey = primaryKey.replace("'", "''");
- }
- DataType colType = tableInfo.getColumn(entry.getKey()).getType();
- ByteBuffer formattedValue = null;
- if(colType.toString().toLowerCase().contains("blob")) {
- formattedValue = MusicUtil.convertToActualDataType(colType, valueObj);
- }
- valueString.append("?");
- queryObject.addValue(formattedValue);
- counter = counter + 1;
- fieldsString.append(",");
- valueString.append(",");
- }
- }
-
- if(primaryKey == null || primaryKey.length() <= 0) {
- logger.error(EELFLoggerDelegate.errorLogger, "Some required partition key parts are missing: "+primaryKeyName );
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.SYNTAXERROR).setError("Some required partition key parts are missing: "+primaryKeyName).toMap()).build();
- }
-
- fieldsString.replace(fieldsString.length()-1, fieldsString.length(), ")");
- valueString.replace(valueString.length()-1, valueString.length(), ")");
-
- queryObject.appendQueryString("INSERT INTO " + keyspace + "." + tablename + " "
- + fieldsString + " VALUES " + valueString);
-
- String ttl = insObj.getTtl();
- String timestamp = insObj.getTimestamp();
-
- if ((ttl != null) && (timestamp != null)) {
- logger.info(EELFLoggerDelegate.applicationLogger, "both there");
- queryObject.appendQueryString(" USING TTL ? AND TIMESTAMP ?");
- queryObject.addValue(Integer.parseInt(ttl));
- queryObject.addValue(Long.parseLong(timestamp));
- }
-
- if ((ttl != null) && (timestamp == null)) {
- logger.info(EELFLoggerDelegate.applicationLogger, "ONLY TTL there");
- queryObject.appendQueryString(" USING TTL ?");
- queryObject.addValue(Integer.parseInt(ttl));
- }
-
- if ((ttl == null) && (timestamp != null)) {
- logger.info(EELFLoggerDelegate.applicationLogger, "ONLY timestamp there");
- queryObject.appendQueryString(" USING TIMESTAMP ?");
- queryObject.addValue(Long.parseLong(timestamp));
- }
-
- queryObject.appendQueryString(";");
-
ReturnType result = null;
String consistency = insObj.getConsistencyInfo().get("type");
- if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL) && insObj.getConsistencyInfo().get("consistency") != null) {
- if(MusicUtil.isValidConsistency(insObj.getConsistencyInfo().get("consistency"))) {
- queryObject.setConsistency(insObj.getConsistencyInfo().get("consistency"));
- } else {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.SYNTAXERROR).setError("Invalid Consistency type").toMap()).build();
- }
- }
- queryObject.setOperation("insert");
try {
- if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL)) {
- result = MusicCore.eventualPut(queryObject);
- } else if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+ insObj.setKeyspaceName(keyspace);
+ insObj.setTableName(tablename);
+ if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
String lockId = insObj.getConsistencyInfo().get("lockId");
if(lockId == null) {
logger.error(EELFLoggerDelegate.errorLogger,"LockId cannot be null. Create lock reference or"
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("LockId cannot be null. Create lock "
+ "and acquire lock or use ATOMIC instead of CRITICAL").toMap()).build();
}
- result = MusicCore.criticalPut(keyspace, tablename, primaryKey, queryObject, lockId,null);
- } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
- result = MusicCore.atomicPut(keyspace, tablename, primaryKey, queryObject, null);
}
- } catch (Exception ex) {
+ result = MusicCore.insertIntoTable(insObj);
+ }catch (MusicQueryException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), ex.getMessage() ,ErrorSeverity
+ .WARN, ErrorTypes.MUSICSERVICEERROR, ex);
+ return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
+ }catch (Exception ex) {
logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity
.WARN, ErrorTypes.MUSICSERVICEERROR, ex);
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
String operationId = UUID.randomUUID().toString(); // just for infoging
// purposes.
String consistency = updateObj.getConsistencyInfo().get("type");
-
+ ReturnType operationResult = null;
logger.info(EELFLoggerDelegate.applicationLogger, "--------------Music " + consistency
+ " update-" + operationId + "-------------------------");
- // obtain the field value pairs of the update
-
- PreparedQueryObject queryObject = new PreparedQueryObject();
- Map<String, Object> valuesMap = updateObj.getValues();
-
- TableMetadata tableInfo;
- try {
- tableInfo = MusicDataStoreHandle.returnColumnMetadata(keyspace, tablename);
- } catch (MusicServiceException e) {
- logger.error(EELFLoggerDelegate.errorLogger,e, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes
- .GENERALSERVICEERROR, e);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();
- }
- if (tableInfo == null) {
- logger.error(EELFLoggerDelegate.errorLogger,"Table information not found. Please check input for table name= "+tablename, AppMessages.MISSINGINFO ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
- .setError("Table information not found. Please check input for table name= "
- + keyspace + "." + tablename).toMap()).build();
- }
- String vectorTs = String.valueOf(Thread.currentThread().getId() + System.currentTimeMillis());
- StringBuilder fieldValueString = new StringBuilder("vector_ts=?,");
- queryObject.addValue(vectorTs);
- int counter = 0;
- for (Map.Entry<String, Object> entry : valuesMap.entrySet()) {
- Object valueObj = entry.getValue();
- DataType colType = null;
- try {
- colType = tableInfo.getColumn(entry.getKey()).getType();
- } catch(NullPointerException ex) {
- logger.error(EELFLoggerDelegate.errorLogger, ex, "Invalid column name : "+entry.getKey(), ex);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("Invalid column name : "+entry.getKey()).toMap()).build();
- }
- Object valueString = null;
- try {
- valueString = MusicUtil.convertToActualDataType(colType, valueObj);
- } catch (Exception e) {
- logger.error(EELFLoggerDelegate.errorLogger,e);
- }
- fieldValueString.append(entry.getKey() + "= ?");
- queryObject.addValue(valueString);
- if (counter != valuesMap.size() - 1) {
- fieldValueString.append(",");
- }
- counter = counter + 1;
- }
- String ttl = updateObj.getTtl();
- String timestamp = updateObj.getTimestamp();
-
- queryObject.appendQueryString("UPDATE " + keyspace + "." + tablename + " ");
- if ((ttl != null) && (timestamp != null)) {
- logger.info("both there");
- queryObject.appendQueryString(" USING TTL ? AND TIMESTAMP ?");
- queryObject.addValue(Integer.parseInt(ttl));
- queryObject.addValue(Long.parseLong(timestamp));
- }
-
- if ((ttl != null) && (timestamp == null)) {
- logger.info("ONLY TTL there");
- queryObject.appendQueryString(" USING TTL ?");
- queryObject.addValue(Integer.parseInt(ttl));
- }
-
- if ((ttl == null) && (timestamp != null)) {
- logger.info("ONLY timestamp there");
- queryObject.appendQueryString(" USING TIMESTAMP ?");
- queryObject.addValue(Long.parseLong(timestamp));
- }
- // get the row specifier
- RowIdentifier rowId = null;
+
+ updateObj.setKeyspaceName(keyspace);
+ updateObj.setTableName(tablename);
+
try {
- rowId = getRowIdentifier(keyspace, tablename, info.getQueryParameters(), queryObject);
- if(rowId == null || rowId.primarKeyValue.isEmpty()) {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
- .setError("Mandatory WHERE clause is missing. Please check the input request.").toMap()).build();
+ if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+ String lockId = updateObj.getConsistencyInfo().get("lockId");
+ if(lockId == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,"LockId cannot be null. Create lock reference or"
+ + " use ATOMIC instead of CRITICAL", ErrorSeverity.FATAL, ErrorTypes.MUSICSERVICEERROR);
+ return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("LockId cannot be null. Create lock "
+ + "and acquire lock or use ATOMIC instead of CRITICAL").toMap()).build();
+ }
}
- } catch (MusicServiceException ex) {
- logger.error(EELFLoggerDelegate.errorLogger,ex, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes
- .GENERALSERVICEERROR, ex);
+ operationResult = MusicCore.updateTable(updateObj,info.getQueryParameters());
+ }catch (MusicLockingException e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN,
+ ErrorTypes.GENERALSERVICEERROR, e);
+ return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();
+ }catch (MusicQueryException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), ex.getMessage() ,ErrorSeverity
+ .WARN, ErrorTypes.MUSICSERVICEERROR, ex);
+ return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
+ }catch (Exception ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity
+ .WARN, ErrorTypes.MUSICSERVICEERROR, ex);
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
- }
-
- queryObject.appendQueryString(
- " SET " + fieldValueString + " WHERE " + rowId.rowIdString + ";");
-
- // get the conditional, if any
- Condition conditionInfo;
- if (updateObj.getConditions() == null) {
- conditionInfo = null;
- } else {
- // to avoid parsing repeatedly, just send the select query to obtain row
- PreparedQueryObject selectQuery = new PreparedQueryObject();
- selectQuery.appendQueryString("SELECT * FROM " + keyspace + "." + tablename + " WHERE "
- + rowId.rowIdString + ";");
- selectQuery.addValue(rowId.primarKeyValue);
- conditionInfo = new Condition(updateObj.getConditions(), selectQuery);
- }
-
- ReturnType operationResult = null;
- long jsonParseCompletionTime = System.currentTimeMillis();
-
- if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL) && updateObj.getConsistencyInfo().get("consistency") != null) {
- if(MusicUtil.isValidConsistency(updateObj.getConsistencyInfo().get("consistency"))) {
- queryObject.setConsistency(updateObj.getConsistencyInfo().get("consistency"));
- } else {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.SYNTAXERROR).setError("Invalid Consistency type").toMap()).build();
- }
- }
- queryObject.setOperation("update");
- if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL)) {
- operationResult = MusicCore.eventualPut(queryObject);
- } else if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
- String lockId = updateObj.getConsistencyInfo().get("lockId");
- if(lockId == null) {
- logger.error(EELFLoggerDelegate.errorLogger,"LockId cannot be null. Create lock reference or"
- + " use ATOMIC instead of CRITICAL", ErrorSeverity.FATAL, ErrorTypes.MUSICSERVICEERROR);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("LockId cannot be null. Create lock "
- + "and acquire lock or use ATOMIC instead of CRITICAL").toMap()).build();
- }
- try {
- operationResult = MusicCore.criticalPut(keyspace, tablename, rowId.primarKeyValue,
- queryObject, lockId, conditionInfo);
- } catch ( Exception e) {
- logger.error(EELFLoggerDelegate.errorLogger,e, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN,
- ErrorTypes.GENERALSERVICEERROR, e);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("Error doing critical put: " + e.getMessage()).toMap()).build();
- }
- } else if (consistency.equalsIgnoreCase("atomic_delete_lock")) {
- // this function is mainly for the benchmarks
- try {
- operationResult = MusicCore.atomicPutWithDeleteLock(keyspace, tablename,
- rowId.primarKeyValue, queryObject, conditionInfo);
- } catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,e, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN,
- ErrorTypes.GENERALSERVICEERROR, e);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();
- }
- } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
- try {
- operationResult = MusicCore.atomicPut(keyspace, tablename, rowId.primarKeyValue,
- queryObject, conditionInfo);
- } catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,e, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR, e);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();
- }
- } else if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL_NB)) {
- operationResult = MusicCore.eventualPut_nb(queryObject, keyspace, tablename, rowId.primarKeyValue);
}
long actualUpdateCompletionTime = System.currentTimeMillis();
long endTime = System.currentTimeMillis();
+ long jsonParseCompletionTime = System.currentTimeMillis();
String timingString = "Time taken in ms for Music " + consistency + " update-" + operationId
+ ":" + "|total operation time:" + (endTime - startTime)
+ "|json parsing time:" + (jsonParseCompletionTime - startTime)
logger.error(EELFLoggerDelegate.errorLogger,ResultType.BODYMISSING.getResult(), AppMessages.MISSINGDATA ,ErrorSeverity.WARN, ErrorTypes.DATAERROR);
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ResultType.BODYMISSING.getResult()).toMap()).build();
}
- PreparedQueryObject queryObject = new PreparedQueryObject();
- StringBuilder columnString = new StringBuilder();
-
- int counter = 0;
- List<String> columnList = delObj.getColumns();
- if (columnList != null) {
- for (String column : columnList) {
- columnString.append(column);
- if (counter != columnList.size() - 1)
- columnString.append(",");
- counter = counter + 1;
- }
- }
-
- // get the row specifier
- RowIdentifier rowId = null;
- try {
- rowId = getRowIdentifier(keyspace, tablename, info.getQueryParameters(), queryObject);
- } catch (MusicServiceException ex) {
- logger.error(EELFLoggerDelegate.errorLogger,ex, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes
- .GENERALSERVICEERROR, ex);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
- }
- String rowSpec = rowId.rowIdString.toString();
-
- if ((columnList != null) && (!rowSpec.isEmpty())) {
- queryObject.appendQueryString("DELETE " + columnString + " FROM " + keyspace + "."
- + tablename + " WHERE " + rowSpec + ";");
- }
-
- if ((columnList == null) && (!rowSpec.isEmpty())) {
- queryObject.appendQueryString("DELETE FROM " + keyspace + "." + tablename + " WHERE "
- + rowSpec + ";");
- }
-
- if ((columnList != null) && (rowSpec.isEmpty())) {
- queryObject.appendQueryString(
- "DELETE " + columnString + " FROM " + keyspace + "." + rowSpec + ";");
- }
- // get the conditional, if any
- Condition conditionInfo;
- if (delObj.getConditions() == null) {
- conditionInfo = null;
- } else {
- // to avoid parsing repeatedly, just send the select query to
- // obtain row
- PreparedQueryObject selectQuery = new PreparedQueryObject();
- selectQuery.appendQueryString("SELECT * FROM " + keyspace + "." + tablename + " WHERE "
- + rowId.rowIdString + ";");
- selectQuery.addValue(rowId.primarKeyValue);
- conditionInfo = new Condition(delObj.getConditions(), selectQuery);
- }
-
- String consistency = delObj.getConsistencyInfo().get("type");
-
-
- if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL) && delObj.getConsistencyInfo().get("consistency")!=null) {
- if(MusicUtil.isValidConsistency(delObj.getConsistencyInfo().get("consistency"))) {
- queryObject.setConsistency(delObj.getConsistencyInfo().get("consistency"));
- } else {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.SYNTAXERROR)
- .setError("Invalid Consistency type").toMap()).build();
- }
- }
ReturnType operationResult = null;
- queryObject.setOperation("delete");
+ String consistency = delObj.getConsistencyInfo().get("type");
+ delObj.setKeyspaceName(keyspace);
+ delObj.setTableName(tablename);
try {
- if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL))
- operationResult = MusicCore.eventualPut(queryObject);
- else if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+ if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
String lockId = delObj.getConsistencyInfo().get("lockId");
if(lockId == null) {
logger.error(EELFLoggerDelegate.errorLogger,"LockId cannot be null. Create lock reference or"
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("LockId cannot be null. Create lock "
+ "and acquire lock or use ATOMIC instead of CRITICAL").toMap()).build();
}
- operationResult = MusicCore.criticalPut(keyspace, tablename, rowId.primarKeyValue,
- queryObject, lockId, conditionInfo);
- } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
- operationResult = MusicCore.atomicPut(keyspace, tablename, rowId.primarKeyValue,
- queryObject, conditionInfo);
- } else if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL_NB)) {
- operationResult = MusicCore.eventualPut_nb(queryObject, keyspace, tablename, rowId.primarKeyValue);
}
+
+ operationResult = MusicCore.deleteFromTable(delObj,info.getQueryParameters());
+ } catch (MusicQueryException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), ex.getMessage() ,ErrorSeverity
+ .WARN, ErrorTypes.MUSICSERVICEERROR, ex);
+ return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
+
} catch (MusicLockingException e) {
logger.error(EELFLoggerDelegate.errorLogger,e, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR, e);
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
.toMap()).build();
}
EELFLoggerDelegate.mdcPut("keyspace", "( "+keyspace+" ) ");
- String consistency = "eventual";// for now this needs only eventual consistency
- PreparedQueryObject query = new PreparedQueryObject();
- query.appendQueryString("DROP TABLE " + keyspace + "." + tablename + ";");
+ JsonTable jsonTable = new JsonTable();
+ jsonTable.setKeyspaceName(keyspace);
+ jsonTable.setTableName(tablename);
try {
- return response.status(Status.OK).entity(new JsonResponse(MusicCore.nonKeyRelatedPut(query, consistency)).toMap()).build();
+ return response.status(Status.OK).entity(new JsonResponse(MusicCore.dropTable(jsonTable, MusicUtil.EVENTUAL)).toMap()).build();
} catch (MusicQueryException ex) {
logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(), AppMessages.QUERYERROR,ErrorSeverity.WARN
, ErrorTypes.QUERYERROR);
logger.error(EELFLoggerDelegate.errorLogger,ResultType.BODYMISSING.getResult() + error, AppMessages.MISSINGDATA ,ErrorSeverity.WARN, ErrorTypes.DATAERROR);
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ResultType.BODYMISSING.getResult() + error).toMap()).build();
}
-
- String lockId = selObj.getConsistencyInfo().get("lockId");
- PreparedQueryObject queryObject = new PreparedQueryObject();
- RowIdentifier rowId = null;
- try {
- rowId = getRowIdentifier(keyspace, tablename, info.getQueryParameters(), queryObject);
- if ( "".equals(rowId)) {
- logger.error(EELFLoggerDelegate.errorLogger,RestMusicDataAPI.PARAMETER_ERROR, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes
- .GENERALSERVICEERROR);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(RestMusicDataAPI.PARAMETER_ERROR).toMap()).build();
- }
- } catch (MusicServiceException ex) {
- logger.error(EELFLoggerDelegate.errorLogger,ex, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes
- .GENERALSERVICEERROR, ex);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
- }
- queryObject.appendQueryString(
- "SELECT * FROM " + keyspace + "." + tablename + " WHERE " + rowId.rowIdString + ";");
-
ResultSet results = null;
-
String consistency = selObj.getConsistencyInfo().get("type");
+ String lockId = selObj.getConsistencyInfo().get("lockId");
+ selObj.setKeyspaceName(keyspace);
+ selObj.setTableName(tablename);
try {
if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
if(lockId == null) {
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("LockId cannot be null. Create lock "
+ "and acquire lock or use ATOMIC instead of CRITICAL").toMap()).build();
}
- results = MusicCore.criticalGet(keyspace, tablename, rowId.primarKeyValue, queryObject,lockId);
- } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
- results = MusicCore.atomicGet(keyspace, tablename, rowId.primarKeyValue, queryObject);
- } else {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
- .setError("Consistency must be: " + MusicUtil.ATOMIC + " or " + MusicUtil.CRITICAL)
- .toMap()).build();
}
- } catch ( MusicLockingException | MusicServiceException me ) {
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("Music Exception" + me.getMessage()).toMap()).build();
- } catch ( Exception ex) {
+ results = MusicCore.selectCritical(selObj, info.getQueryParameters());
+ }catch (MusicQueryException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), ex.getMessage() ,ErrorSeverity
+ .WARN, ErrorTypes.MUSICSERVICEERROR, ex);
+ return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
+
+ }catch(Exception ex) {
return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
}
-
+
if(results!=null && results.getAvailableWithoutFetching() >0) {
return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS).setDataResult(MusicDataStoreHandle.marshallResults(results)).toMap()).build();
}
.toMap()).build();
}
EELFLoggerDelegate.mdcPut("keyspace", "( " + keyspace + " ) ");
- PreparedQueryObject queryObject = new PreparedQueryObject();
-
- if (info.getQueryParameters().isEmpty()) { // select all
- queryObject.appendQueryString("SELECT * FROM " + keyspace + "." + tablename + ";");
- } else {
- int limit = -1; // do not limit the number of results
- try {
- queryObject = selectSpecificQuery(keyspace, tablename, info, limit);
- } catch (MusicServiceException ex) {
- logger.error(EELFLoggerDelegate.errorLogger, ex, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN,
- ErrorTypes.GENERALSERVICEERROR, ex);
- return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
- }
- }
try {
- ResultSet results = MusicCore.get(queryObject);
+ JsonSelect jsonSelect = new JsonSelect();
+ jsonSelect.setKeyspaceName(keyspace);
+ jsonSelect.setTableName(tablename);
+ ResultSet results = MusicCore.select(jsonSelect, info.getQueryParameters());
if(results.getAvailableWithoutFetching() >0) {
return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS).setDataResult(MusicDataStoreHandle.marshallResults(results)).toMap()).build();
}
return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS).setDataResult(MusicDataStoreHandle.marshallResults(results)).setError("No data found").toMap()).build();
+ } catch (MusicQueryException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), ex.getMessage() ,ErrorSeverity
+ .WARN, ErrorTypes.MUSICSERVICEERROR, ex);
+ return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
+
} catch (MusicServiceException ex) {
logger.error(EELFLoggerDelegate.errorLogger, ex, AppMessages.UNKNOWNERROR ,ErrorSeverity.ERROR,
ErrorTypes.MUSICSERVICEERROR, ex);
import java.util.List;
import java.util.Map;
+import javax.ws.rs.core.MultivaluedMap;
+
+import org.onap.music.datastore.Condition;
import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.datastore.jsonobjects.JsonDelete;
+import org.onap.music.datastore.jsonobjects.JsonIndex;
+import org.onap.music.datastore.jsonobjects.JsonInsert;
+import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+import org.onap.music.datastore.jsonobjects.JsonSelect;
+import org.onap.music.datastore.jsonobjects.JsonTable;
+import org.onap.music.datastore.jsonobjects.JsonUpdate;
import org.onap.music.exceptions.MusicLockingException;
import org.onap.music.exceptions.MusicQueryException;
import org.onap.music.exceptions.MusicServiceException;
import org.onap.music.lockingservice.cassandra.MusicLockState;
import org.onap.music.main.ResultType;
import org.onap.music.main.ReturnType;
-import org.onap.music.datastore.*;
import com.datastax.driver.core.ResultSet;
public Map<String, Object> validateLock(String lockName);
public MusicLockState releaseLock(String lockId, boolean voluntaryRelease) throws MusicLockingException;
+
+
+ //Methods added for orm
+
+
+ public ResultType createTable(JsonTable jsonTableObject, String consistencyInfo) throws MusicServiceException,MusicQueryException;
+
+ public ResultType dropTable(JsonTable jsonTableObject, String consistencyInfo)
+ throws MusicServiceException,MusicQueryException;
+
+ public ResultType createKeyspace(JsonKeySpace jsonKeySpaceObject,String consistencyInfo) throws MusicServiceException,MusicQueryException;
+
+ public ResultType dropKeyspace(JsonKeySpace jsonKeySpaceObject, String consistencyInfo)
+ throws MusicServiceException,MusicQueryException;
+
+ public ResultType createIndex(JsonIndex jsonIndexObject, String consistencyInfo) throws MusicServiceException,MusicQueryException;
+
+ public ResultSet select(JsonSelect jsonSelect, MultivaluedMap<String, String> rowParams) throws MusicServiceException, MusicQueryException;
+
+ public ResultSet selectCritical(JsonInsert jsonInsertObj, MultivaluedMap<String, String> rowParams)
+ throws MusicLockingException, MusicQueryException, MusicServiceException;
+
+ public ReturnType insertIntoTable(JsonInsert jsonInsert) throws MusicLockingException, MusicQueryException, MusicServiceException;
+
+ public ReturnType updateTable(JsonUpdate jsonUpdateObj,MultivaluedMap<String, String> rowParams)
+ throws MusicLockingException, MusicQueryException, MusicServiceException;
+
+ public ReturnType deleteFromTable(JsonDelete jsonDeleteObj,MultivaluedMap<String, String> rowParams)
+ throws MusicLockingException, MusicQueryException, MusicServiceException;
}
import java.util.Map;
import java.util.StringTokenizer;
+import javax.ws.rs.core.MultivaluedMap;
+
+import org.onap.music.datastore.Condition;
import org.onap.music.datastore.MusicDataStore;
import org.onap.music.datastore.MusicDataStoreHandle;
import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.datastore.jsonobjects.JsonDelete;
+import org.onap.music.datastore.jsonobjects.JsonIndex;
+import org.onap.music.datastore.jsonobjects.JsonInsert;
+import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+import org.onap.music.datastore.jsonobjects.JsonSelect;
+import org.onap.music.datastore.jsonobjects.JsonTable;
+import org.onap.music.datastore.jsonobjects.JsonUpdate;
import org.onap.music.eelf.logging.EELFLoggerDelegate;
import org.onap.music.eelf.logging.format.AppMessages;
import org.onap.music.eelf.logging.format.ErrorSeverity;
import com.datastax.driver.core.Row;
import com.datastax.driver.core.TableMetadata;
-import org.onap.music.datastore.*;
-
public class MusicCassaCore implements MusicCoreService {
private static CassaLockStore mLockHandle = null;
//deprecated
return null;
}
+
+ //Methods added for ORM changes
+
+ public ResultType createKeyspace(JsonKeySpace jsonKeySpaceObject,String consistencyInfo)
+ throws MusicServiceException,MusicQueryException {
+ ResultType result = nonKeyRelatedPut(jsonKeySpaceObject.genCreateKeyspaceQuery(), consistencyInfo);
+ logger.info(EELFLoggerDelegate.applicationLogger, " Keyspace Creation Process completed successfully");
+
+ return result;
+ }
+
+ public ResultType dropKeyspace(JsonKeySpace jsonKeySpaceObject, String consistencyInfo)
+ throws MusicServiceException,MusicQueryException {
+ ResultType result = nonKeyRelatedPut(jsonKeySpaceObject.genDropKeyspaceQuery(),
+ consistencyInfo);
+ logger.info(EELFLoggerDelegate.applicationLogger, " Keyspace deletion Process completed successfully");
+ return result;
+ }
+
+ public ResultType createTable(JsonTable jsonTableObject, String consistencyInfo)
+ throws MusicServiceException, MusicQueryException {
+ ResultType result = null;
+ try {
+ result = createTable(jsonTableObject.getKeyspaceName(),
+ jsonTableObject.getTableName(), jsonTableObject.genCreateTableQuery(), consistencyInfo);
+
+ } catch (MusicServiceException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(), AppMessages.UNKNOWNERROR, ErrorSeverity.WARN,
+ ErrorTypes.MUSICSERVICEERROR);
+ throw new MusicServiceException(ex.getMessage());
+ }
+ logger.info(EELFLoggerDelegate.applicationLogger, " Table Creation Process completed successfully ");
+ return result;
+ }
+
+ public ResultType dropTable(JsonTable jsonTableObject,String consistencyInfo)
+ throws MusicServiceException,MusicQueryException {
+ ResultType result = nonKeyRelatedPut(jsonTableObject.genDropTableQuery(),
+ consistencyInfo);
+ logger.info(EELFLoggerDelegate.applicationLogger, " Table deletion Process completed successfully ");
+
+ return result;
+ }
+
+ @Override
+ public ResultType createIndex(JsonIndex jsonIndexObject, String consistencyInfo)
+ throws MusicServiceException, MusicQueryException{
+ ResultType result = nonKeyRelatedPut(jsonIndexObject.genCreateIndexQuery(),
+ consistencyInfo);
+
+ logger.info(EELFLoggerDelegate.applicationLogger, " Index creation Process completed successfully ");
+ return result;
+ }
+
+ /**
+ * This method performs DDL operation on cassandra.
+ *
+ * @param queryObject query object containing prepared query and values
+ * @return ResultSet
+ * @throws MusicServiceException
+ */
+ public ResultSet select(JsonSelect jsonSelect, MultivaluedMap<String, String> rowParams)
+ throws MusicServiceException, MusicQueryException {
+ ResultSet results = null;
+ try {
+ results = get(jsonSelect.genSelectQuery(rowParams));
+ } catch (MusicServiceException e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage());
+ throw new MusicServiceException(e.getMessage());
+ }
+ return results;
+ }
+
+ /**
+ * Select Critical
+ */
+ public ResultSet selectCritical(JsonInsert jsonInsertObj, MultivaluedMap<String, String> rowParams)
+ throws MusicLockingException, MusicQueryException, MusicServiceException {
+
+ ResultSet results = null;
+ String consistency = "";
+ if(null != jsonInsertObj && null != jsonInsertObj.getConsistencyInfo()) {
+ consistency = jsonInsertObj.getConsistencyInfo().get("type");
+ }
+
+ String lockId = jsonInsertObj.getConsistencyInfo().get("lockId");
+
+ PreparedQueryObject queryObject = jsonInsertObj.genSelectCriticalPreparedQueryObj(rowParams);
+
+ if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+ results = criticalGet(jsonInsertObj.getKeyspaceName(), jsonInsertObj.getTableName(),
+ jsonInsertObj.getPrimaryKeyVal(), queryObject,lockId);
+ } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
+ results = atomicGet(jsonInsertObj.getKeyspaceName(), jsonInsertObj.getTableName(),
+ jsonInsertObj.getPrimaryKeyVal(), queryObject);
+ }
+
+ return results;
+ }
+
+ /**
+ * this is insert row into Table
+ */
+ public ReturnType insertIntoTable(JsonInsert jsonInsertObj)
+ throws MusicLockingException, MusicQueryException, MusicServiceException {
+
+ String consistency = "";
+ if(null != jsonInsertObj && null != jsonInsertObj.getConsistencyInfo()) {
+ consistency = jsonInsertObj.getConsistencyInfo().get("type");
+ }
+
+ ReturnType result = null;
+
+ try {
+ PreparedQueryObject queryObj = null;
+ queryObj = jsonInsertObj.genInsertPreparedQueryObj();
+
+ if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL)) {
+ result = eventualPut(jsonInsertObj.genInsertPreparedQueryObj());
+ } else if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+ String lockId = jsonInsertObj.getConsistencyInfo().get("lockId");
+ if(lockId == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,"LockId cannot be null. Create lock reference or"
+ + " use ATOMIC instead of CRITICAL", ErrorSeverity.FATAL, ErrorTypes.MUSICSERVICEERROR);
+ return new ReturnType(ResultType.FAILURE, "LockId cannot be null. Create lock "
+ + "and acquire lock or use ATOMIC instead of CRITICAL");
+ }
+ result = criticalPut(jsonInsertObj.getKeyspaceName(),
+ jsonInsertObj.getTableName(), jsonInsertObj.getPrimaryKeyVal(), jsonInsertObj.genInsertPreparedQueryObj(), lockId,null);
+ } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
+ result = atomicPut(jsonInsertObj.getKeyspaceName(), jsonInsertObj.getTableName(),
+ jsonInsertObj.getPrimaryKeyVal(), jsonInsertObj.genInsertPreparedQueryObj(), null);
+ }
+ } catch (Exception ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity
+ .WARN, ErrorTypes.MUSICSERVICEERROR, ex);
+ return new ReturnType(ResultType.FAILURE, ex.getMessage());
+ }
+
+ return result;
+ }
+
+ /**
+ * This is insert row into Table
+ */
+ public ReturnType updateTable(JsonUpdate jsonUpdateObj, MultivaluedMap<String, String> rowParams)
+ throws MusicLockingException, MusicQueryException, MusicServiceException {
+
+ ReturnType result = null;
+ String consistency = "";
+ if(null != jsonUpdateObj && null != jsonUpdateObj.getConsistencyInfo()) {
+ consistency = jsonUpdateObj.getConsistencyInfo().get("type");
+ }
+ PreparedQueryObject queryObject = jsonUpdateObj.genUpdatePreparedQueryObj(rowParams);
+
+ Condition conditionInfo;
+ if (jsonUpdateObj.getConditions() == null) {
+ conditionInfo = null;
+ } else {
+ // to avoid parsing repeatedly, just send the select query to obtain row
+ PreparedQueryObject selectQuery = new PreparedQueryObject();
+ selectQuery.appendQueryString("SELECT * FROM " + jsonUpdateObj.getKeyspaceName() + "." + jsonUpdateObj.getTableName() + " WHERE "
+ + jsonUpdateObj.getRowIdString() + ";");
+ selectQuery.addValue(jsonUpdateObj.getPrimarKeyValue());
+ conditionInfo = new Condition(jsonUpdateObj.getConditions(), selectQuery);
+ }
+
+
+ if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL)) {
+ result = eventualPut(queryObject);
+ } else if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+ String lockId = jsonUpdateObj.getConsistencyInfo().get("lockId");
+ if(lockId == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,"LockId cannot be null. Create lock reference or"
+ + " use ATOMIC instead of CRITICAL", ErrorSeverity.FATAL, ErrorTypes.MUSICSERVICEERROR);
+
+ return new ReturnType(ResultType.FAILURE, "LockId cannot be null. Create lock "
+ + "and acquire lock or use ATOMIC instead of CRITICAL");
+ }
+ result = criticalPut(jsonUpdateObj.getKeyspaceName(), jsonUpdateObj.getTableName(), jsonUpdateObj.getPrimarKeyValue(),
+ queryObject, lockId, conditionInfo);
+ } else if (consistency.equalsIgnoreCase("atomic_delete_lock")) {
+ // this function is mainly for the benchmarks
+ try {
+ result = atomicPutWithDeleteLock(jsonUpdateObj.getKeyspaceName(), jsonUpdateObj.getTableName(),
+ jsonUpdateObj.getPrimarKeyValue(), queryObject, conditionInfo);
+ } catch (MusicLockingException e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN,
+ ErrorTypes.GENERALSERVICEERROR, e);
+ throw new MusicLockingException(AppMessages.UNKNOWNERROR.toString());
+
+ }
+ } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
+ try {
+ result = atomicPut(jsonUpdateObj.getKeyspaceName(), jsonUpdateObj.getTableName(), jsonUpdateObj.getPrimarKeyValue(),
+ queryObject, conditionInfo);
+ } catch (MusicLockingException e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e, AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR, e);
+ throw new MusicLockingException(AppMessages.UNKNOWNERROR.toString());
+ }
+ } else if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL_NB)) {
+ try {
+ result = eventualPut_nb(queryObject, jsonUpdateObj.getKeyspaceName(),
+ jsonUpdateObj.getTableName(), jsonUpdateObj.getPrimarKeyValue());
+ }catch (Exception e) {
+ return new ReturnType(ResultType.FAILURE, e.getMessage());
+ }
+
+ }
+
+ return result;
+ }
+
+ /**
+ * This method is for Delete From Table
+ */
+ public ReturnType deleteFromTable(JsonDelete jsonDeleteObj, MultivaluedMap<String, String> rowParams)
+ throws MusicLockingException, MusicQueryException, MusicServiceException {
+
+ ReturnType result = null;
+ String consistency = "";
+ if(null != jsonDeleteObj && null != jsonDeleteObj.getConsistencyInfo()) {
+ consistency = jsonDeleteObj.getConsistencyInfo().get("type");
+ }
+ PreparedQueryObject queryObject = jsonDeleteObj.genDeletePreparedQueryObj(rowParams);
+
+ // get the conditional, if any
+ Condition conditionInfo;
+ if (jsonDeleteObj.getConditions() == null) {
+ conditionInfo = null;
+ } else {
+ // to avoid parsing repeatedly, just send the select query to obtain row
+ PreparedQueryObject selectQuery = new PreparedQueryObject();
+ selectQuery.appendQueryString("SELECT * FROM " + jsonDeleteObj.getKeyspaceName() + "." + jsonDeleteObj.getTableName() + " WHERE "
+ + jsonDeleteObj.getRowIdString() + ";");
+ selectQuery.addValue(jsonDeleteObj.getPrimarKeyValue());
+ conditionInfo = new Condition(jsonDeleteObj.getConditions(), selectQuery);
+ }
+
+ if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL))
+ result = eventualPut(queryObject);
+ else if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+ String lockId = jsonDeleteObj.getConsistencyInfo().get("lockId");
+ if(lockId == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,"LockId cannot be null. Create lock reference or"
+ + " use ATOMIC instead of CRITICAL", ErrorSeverity.FATAL, ErrorTypes.MUSICSERVICEERROR);
+
+ return new ReturnType(ResultType.FAILURE, "LockId cannot be null. Create lock "
+ + "and acquire lock or use ATOMIC instead of CRITICAL");
+ }
+ result = criticalPut(jsonDeleteObj.getKeyspaceName(),
+ jsonDeleteObj.getTableName(), jsonDeleteObj.getPrimarKeyValue(),
+ queryObject, lockId, conditionInfo);
+ } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
+ result = atomicPut(jsonDeleteObj.getKeyspaceName(),
+ jsonDeleteObj.getTableName(), jsonDeleteObj.getPrimarKeyValue(),
+ queryObject, conditionInfo);
+ } else if(consistency.equalsIgnoreCase(MusicUtil.EVENTUAL_NB)) {
+ result = eventualPut_nb(queryObject, jsonDeleteObj.getKeyspaceName(),
+ jsonDeleteObj.getTableName(), jsonDeleteObj.getPrimarKeyValue());
+ }
+
+ return result;
+ }
}
Code Review / music.git / commitdiff