Merge "MUSIC-ORM-Implemetation"

11 files changed, 1872 insertions, 644 deletions

diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonDelete.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonDelete.java
index b9b82e08..7ea691f0 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonDelete.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonDelete.java
@@ -6,6 +6,8 @@
  * ===================================================================
  *  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
@@ -27,6 +29,22 @@ package org.onap.music.datastore.jsonobjects;
 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;
@@ -36,11 +54,17 @@ import io.swagger.annotations.ApiModelProperty;
 @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")
@@ -88,4 +112,209 @@ public class JsonDelete {
     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;
+       }
+   }
 }
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonIndex.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonIndex.java
new file mode 100644
index 00000000..a06e8ea9
--- /dev/null
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonIndex.java
@@ -0,0 +1,120 @@
+/*
+ * ============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;
+    }
+
+}
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonInsert.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonInsert.java
index d3ec10da..8e8404b7 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonInsert.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonInsert.java
@@ -3,7 +3,7 @@
  * 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.
@@ -28,17 +28,30 @@ import java.io.IOException;
 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)
@@ -52,6 +65,7 @@ public class JsonInsert implements Serializable {
     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)
@@ -133,6 +147,14 @@ public class JsonInsert implements Serializable {
     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();
@@ -145,5 +167,267 @@ public class JsonInsert implements Serializable {
         }
         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);
+    }
+
 
 }
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonKeySpace.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonKeySpace.java
index f2232ffd..cada1c00 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonKeySpace.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonKeySpace.java
@@ -4,6 +4,8 @@
  * ===================================================================
  *  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
@@ -24,6 +26,16 @@ package org.onap.music.datastore.jsonobjects;
 
 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;
@@ -32,6 +44,7 @@ import io.swagger.annotations.ApiModelProperty;
 @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;
@@ -73,6 +86,78 @@ public class JsonKeySpace {
         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 + "]";
+    }
 
 }
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonSelect.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonSelect.java
index 2230f267..4d4ab2ac 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonSelect.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonSelect.java
@@ -3,7 +3,7 @@
  * 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.
@@ -28,14 +28,31 @@ import java.io.IOException;
 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);
 
 
@@ -47,6 +64,22 @@ public class JsonSelect implements Serializable {
     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();
@@ -59,5 +92,117 @@ public class JsonSelect implements Serializable {
         }
         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);
+    }
 
 }
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonTable.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonTable.java
index badcaebe..83b5a7a5 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonTable.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonTable.java
@@ -4,6 +4,8 @@
  * ===================================================================
  *  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
@@ -24,6 +26,14 @@ package org.onap.music.datastore.jsonobjects;
 
 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;
@@ -32,6 +42,8 @@ import io.swagger.annotations.ApiModelProperty;
 @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;
 
@@ -130,6 +142,245 @@ public class JsonTable {
     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;
+    }
 
 
 }
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonUpdate.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonUpdate.java
index e31c6ccf..12508de0 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonUpdate.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonUpdate.java
@@ -3,7 +3,7 @@
  * 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.
@@ -28,17 +28,31 @@ import java.io.IOException;
 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)
@@ -51,6 +65,8 @@ public class JsonUpdate implements Serializable {
     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")
@@ -125,6 +141,22 @@ public class JsonUpdate implements Serializable {
     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();
@@ -137,5 +169,248 @@ public class JsonUpdate implements Serializable {
         }
         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);
+    }
 
 }
diff --git a/src/main/java/org/onap/music/main/MusicCore.java b/src/main/java/org/onap/music/main/MusicCore.java
index 1f1d6a16..da94e1a6 100644
--- a/src/main/java/org/onap/music/main/MusicCore.java
+++ b/src/main/java/org/onap/music/main/MusicCore.java
@@ -24,8 +24,18 @@ package org.onap.music.main;
 
 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;
@@ -34,6 +44,7 @@ import org.onap.music.lockingservice.cassandra.CassaLockStore;
 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 {
@@ -181,6 +192,58 @@ 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);
+    }
 
 
 
diff --git a/src/main/java/org/onap/music/rest/RestMusicDataAPI.java b/src/main/java/org/onap/music/rest/RestMusicDataAPI.java
index 39778338..756856d0 100755
--- a/src/main/java/org/onap/music/rest/RestMusicDataAPI.java
+++ b/src/main/java/org/onap/music/rest/RestMusicDataAPI.java
@@ -6,6 +6,8 @@
  * ===================================================================
  *  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
@@ -24,7 +26,6 @@
 
 package org.onap.music.rest;
 
-import java.nio.ByteBuffer;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
@@ -46,23 +47,23 @@ import javax.ws.rs.core.Response.ResponseBuilder;
 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;
@@ -73,12 +74,10 @@ import com.datastax.driver.core.ResultSet;
 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;
 
@@ -180,41 +179,11 @@ public class RestMusicDataAPI {
                     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);
@@ -276,11 +245,11 @@ public class RestMusicDataAPI {
             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();
                     }
@@ -358,180 +327,15 @@ public class RestMusicDataAPI {
             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);
@@ -601,13 +405,12 @@ public class RestMusicDataAPI {
             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);
@@ -674,143 +477,12 @@ public class RestMusicDataAPI {
                 .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"
@@ -818,11 +490,13 @@ public class RestMusicDataAPI {
                         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();
@@ -889,159 +563,41 @@ public class RestMusicDataAPI {
             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)
@@ -1115,76 +671,12 @@ public class RestMusicDataAPI {
                 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"
@@ -1192,14 +684,14 @@ public class RestMusicDataAPI {
                         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)
@@ -1265,11 +757,11 @@ public class RestMusicDataAPI {
                     .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);
@@ -1351,28 +843,11 @@ public class RestMusicDataAPI {
                 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) {
@@ -1381,20 +856,17 @@ public class RestMusicDataAPI {
                         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();
             }
@@ -1481,26 +953,20 @@ public class RestMusicDataAPI {
                     .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);
diff --git a/src/main/java/org/onap/music/service/MusicCoreService.java b/src/main/java/org/onap/music/service/MusicCoreService.java
index 9bbef9c1..c96d2b30 100644
--- a/src/main/java/org/onap/music/service/MusicCoreService.java
+++ b/src/main/java/org/onap/music/service/MusicCoreService.java
@@ -25,7 +25,17 @@ package org.onap.music.service;
 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;
@@ -33,7 +43,6 @@ import org.onap.music.lockingservice.cassandra.LockType;
 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;
 
@@ -134,5 +143,34 @@ public interface MusicCoreService {
     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;
 
 }
diff --git a/src/main/java/org/onap/music/service/impl/MusicCassaCore.java b/src/main/java/org/onap/music/service/impl/MusicCassaCore.java
index 07864576..04fcfd23 100644
--- a/src/main/java/org/onap/music/service/impl/MusicCassaCore.java
+++ b/src/main/java/org/onap/music/service/impl/MusicCassaCore.java
@@ -30,9 +30,19 @@ import java.util.List;
 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;
@@ -55,8 +65,6 @@ import com.datastax.driver.core.ResultSet;
 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;
@@ -813,6 +821,270 @@ public class MusicCassaCore implements MusicCoreService {
         //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;
+    }
 
 
 }