Initial code Import.

Issue-ID: MUSIC-21

Change-Id: I89ceab0891b4b7cb999dab532d6bae9092f027cc
Signed-off-by: arthurdent3 <tn1381@att.com>

1 files changed, 1088 insertions, 0 deletions

diff --git a/src/main/java/org/onap/music/rest/RestMusicDataAPI.java b/src/main/java/org/onap/music/rest/RestMusicDataAPI.java
new file mode 100755
index 00000000..ba0f1a3b
--- /dev/null
+++ b/src/main/java/org/onap/music/rest/RestMusicDataAPI.java
@@ -0,0 +1,1088 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 AT&T Intellectual Property
+ * ===================================================================
+ *  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.rest;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+// import java.util.logging.Level;
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.UriInfo;
+import com.att.eelf.configuration.EELFLogger;
+import com.att.eelf.configuration.EELFManager;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.datastore.jsonobjects.JsonDelete;
+import org.onap.music.datastore.jsonobjects.JsonInsert;
+import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+import org.onap.music.response.jsonobjects.JsonResponse;
+import org.onap.music.datastore.jsonobjects.JsonTable;
+import org.onap.music.datastore.jsonobjects.JsonUpdate;
+import org.onap.music.main.CachingUtil;
+import org.onap.music.main.MusicCore;
+import org.onap.music.main.MusicUtil;
+import org.onap.music.main.ResultType;
+import org.onap.music.main.ReturnType;
+import org.onap.music.main.MusicCore.Condition;
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.TableMetadata;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+
+@Path("/v{version: [0-9]+}/keyspaces")
+@Api(value = "Data Api")
+public class RestMusicDataAPI {
+    /*
+     * Header values for Versioning X-minorVersion *** - Used to request or communicate a MINOR
+     * version back from the client to the server, and from the server back to the client - This
+     * will be the MINOR version requested by the client, or the MINOR version of the last MAJOR
+     * version (if not specified by the client on the request) - Contains a single position value
+     * (e.g. if the full version is 1.24.5, X-minorVersion = "24") - Is optional for the client on
+     * request; however, this header should be provided if the client needs to take advantage of
+     * MINOR incremented version functionality - Is mandatory for the server on response
+     * 
+     *** X-patchVersion *** - Used only to communicate a PATCH version in a response for
+     * troubleshooting purposes only, and will not be provided by the client on request - This will
+     * be the latest PATCH version of the MINOR requested by the client, or the latest PATCH version
+     * of the MAJOR (if not specified by the client on the request) - Contains a single position
+     * value (e.g. if the full version is 1.24.5, X-patchVersion = "5") - Is mandatory for the
+     * server on response
+     *
+     *** X-latestVersion *** - Used only to communicate an API's latest version - Is mandatory for the
+     * server on response, and shall include the entire version of the API (e.g. if the full version
+     * is 1.24.5, X-latestVersion = "1.24.5") - Used in the response to inform clients that they are
+     * not using the latest version of the API
+     *
+     */
+
+
+    private static EELFLogger logger = EELFManager.getInstance().getLogger(RestMusicDataAPI.class);
+    private static String xLatestVersion = "X-latestVersion";
+
+    private class RowIdentifier {
+        public String primarKeyValue;
+        public StringBuilder rowIdString;
+        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;
+        }
+    }
+
+    private String buildVersion(String major, String minor, String patch) {
+        if (minor != null) {
+            major += "." + minor;
+            if (patch != null) {
+                major += "." + patch;
+            }
+        }
+        return major;
+    }
+
+    /**
+     * Create Keyspace REST
+     * 
+     * @param kspObject
+     * @param keyspaceName
+     * @return
+     * @throws Exception
+     */
+    @POST
+    @Path("/{name}")
+    @ApiOperation(value = "Create Keyspace", response = String.class)
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map<String, Object> createKeySpace(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    JsonKeySpace kspObject,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("name") String keyspaceName,
+                    @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap = CachingUtil.verifyOnboarding(ns, userId, password);
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (!resultMap.isEmpty()) {
+            return resultMap;
+        }
+
+        resultMap = MusicCore.autheticateUser(ns, userId, password, keyspaceName, aid,
+                        "createKeySpace");
+        String newAid = null;
+        if (!resultMap.isEmpty()) {
+            if (resultMap.containsKey("aid")) {
+                newAid = (String) resultMap.get("aid");
+            } else
+                return resultMap;
+        }
+
+        String consistency = MusicUtil.EVENTUAL;// for now this needs only eventual
+                                        // consistency
+
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        boolean result = false;
+        long start = System.currentTimeMillis();
+        Map<String, Object> replicationInfo = kspObject.getReplicationInfo();
+        String repString = "{" + MusicUtil.jsonMaptoSqlString(replicationInfo, ",") + "}";
+        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("Time taken for setting up query in create keyspace:" + (end - start));
+
+        try {
+            result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
+            logger.debug("resulta = " + result);
+        } catch (Exception e) {
+            logger.error(e.getMessage());
+
+        }
+        logger.debug("result = " + result);
+        if (!result) {
+            resultMap.put("Status", String.valueOf(result));
+            resultMap.put("Exception", "Keyspace already exists. Please contact admin.");
+            if (resultMap.get("uuid").equals("new")) {
+                queryObject = new PreparedQueryObject();
+                queryObject.appendQueryString(
+                                "DELETE FROM admin.keyspace_master where uuid = " + newAid);
+                queryObject.appendQueryString(";");
+                result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
+                resultMap.remove("aid");
+                resultMap.remove("uuid");
+                return resultMap;
+
+            } else {
+                queryObject = new PreparedQueryObject();
+                queryObject.appendQueryString(
+                                "UPDATE admin.keyspace_master SET keyspace_name=?,password=?,is_api=null where uuid = ?;");
+                queryObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
+                                MusicUtil.DEFAULTKEYSPACENAME));
+                queryObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), null));
+                queryObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), newAid));
+                result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
+                resultMap.remove("aid");
+                resultMap.remove("uuid");
+                return resultMap;
+            }
+
+        }
+        try {
+            queryObject = new PreparedQueryObject();
+            queryObject.appendQueryString("CREATE ROLE IF NOT EXISTS '" + userId
+                            + "' WITH PASSWORD = '" + password + "' AND LOGIN = true;");
+            result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
+            if (result) {
+                queryObject = new PreparedQueryObject();
+                queryObject.appendQueryString("GRANT ALL PERMISSIONS on KEYSPACE " + keyspaceName
+                                + " to " + userId);
+                queryObject.appendQueryString(";");
+                result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
+            } else {
+                resultMap.remove("uuid");
+                resultMap.put("Exception", "Exception while creating user.");
+                return resultMap;
+            }
+        } catch (Exception e) {
+            logger.error(e.getMessage());
+        }
+        resultMap.remove("uuid");
+        if (CachingUtil.isAAFApplication(ns))
+            resultMap.remove("aid");
+        resultMap.put("Status", String.valueOf(result));
+        return resultMap;
+
+    }
+
+    /**
+     * 
+     * @param kspObject
+     * @param keyspaceName
+     * @return
+     * @throws Exception
+     */
+    @DELETE
+    @Path("/{name}")
+    @ApiOperation(value = "Delete Keyspace", response = String.class)
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map<String, Object> dropKeySpace(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    JsonKeySpace kspObject,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("name") String keyspaceName,
+                    @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap = MusicCore.autheticateUser(ns, userId, password,
+                        keyspaceName, aid, "dropKeySpace");
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (resultMap.containsKey("aid"))
+            resultMap.remove("aid");
+        if (!resultMap.isEmpty()) {
+            return resultMap;
+        }
+
+        String consistency = MusicUtil.EVENTUAL;// for now this needs only eventual
+                                        // consistency
+        String appName = CachingUtil.getAppName(keyspaceName);
+        String uuid = CachingUtil.getUuidFromMusicCache(keyspaceName);
+        PreparedQueryObject pQuery = new PreparedQueryObject();
+        pQuery.appendQueryString(
+                        "select  count(*) as count from admin.keyspace_master where application_name=? allow filtering;");
+        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
+        Row row = MusicCore.get(pQuery).one();
+        long count = row.getLong(0);
+
+        if (count == 0) {
+            resultMap.put("Exception", "Keyspace not found. Please make sure keyspace exists.");
+            return resultMap;
+        } else if (count == 1) {
+            pQuery = new PreparedQueryObject();
+            pQuery.appendQueryString(
+                            "UPDATE admin.keyspace_master SET keyspace_name=?,password=?,is_api=null where uuid = ?;");
+            pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(),
+                            MusicUtil.DEFAULTKEYSPACENAME));
+            pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), null));
+            pQuery.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
+            MusicCore.nonKeyRelatedPut(pQuery, consistency);
+        } else {
+            pQuery = new PreparedQueryObject();
+            pQuery.appendQueryString("delete from admin.keyspace_master where uuid = ?");
+            pQuery.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
+            MusicCore.nonKeyRelatedPut(pQuery, consistency);
+        }
+
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        queryObject.appendQueryString("DROP KEYSPACE " + keyspaceName + ";");
+        return new JsonResponse(MusicCore.nonKeyRelatedPut(queryObject, consistency), "", "")
+                        .toMap();
+    }
+
+    /**
+     * 
+     * @param tableObj
+     * @param keyspace
+     * @param tablename
+     * @return
+     * @throws Exception
+     */
+    @POST
+    @Path("/{keyspace}/tables/{tablename}")
+    @ApiOperation(value = "Create Table", response = String.class)
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map<String, Object> createTable(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    JsonTable tableObj,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("keyspace") String keyspace,
+                    @ApiParam(value = "Table Name",
+                                    required = true) @PathParam("tablename") String tablename,
+                    @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+                        aid, "createTable");
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (resultMap.containsKey("aid"))
+            resultMap.remove("aid");
+        if (!resultMap.isEmpty()) {
+            return resultMap;
+        }
+        String consistency = MusicUtil.EVENTUAL;
+        // for now this needs only eventual consistency
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        boolean result = false;
+        // first read the information about the table fields
+        Map<String, String> fields = tableObj.getFields();
+        StringBuilder fieldsString = new StringBuilder("(vector_ts text,");
+        int counter = 0;
+        String primaryKey;
+        for (Map.Entry<String, String> entry : fields.entrySet()) {
+            fieldsString.append("" + entry.getKey() + " " + entry.getValue() + "");
+            if (entry.getKey().equals("PRIMARY KEY")) {
+                primaryKey = entry.getValue().substring(entry.getValue().indexOf('(') + 1);
+                primaryKey = primaryKey.substring(0, primaryKey.indexOf(')'));
+            }
+            if (counter == fields.size() - 1)
+                fieldsString.append(")");
+            else
+                fieldsString.append(",");
+            counter = counter + 1;
+        }
+        // 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) {
+                    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;
+            }
+        }
+
+        queryObject.appendQueryString("CREATE TABLE IF NOT EXISTS " + keyspace + "." + tablename
+                        + " " + fieldsString);
+
+        if (propertiesMap != null)
+            queryObject.appendQueryString(" WITH " + propertiesString);
+
+        queryObject.appendQueryString(";");
+        result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
+
+        return new JsonResponse(result, "", "").toMap();
+    }
+
+    /**
+     * 
+     * @param keyspace
+     * @param tablename
+     * @param fieldName
+     * @param info
+     * @throws Exception
+     */
+    @POST
+    @Path("/{keyspace}/tables/{tablename}/index/{field}")
+    @ApiOperation(value = "Create Index", response = String.class)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map<String, Object> createIndex(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("keyspace") String keyspace,
+                    @ApiParam(value = "Table Name",
+                                    required = true) @PathParam("tablename") String tablename,
+                    @ApiParam(value = "Field Name",
+                                    required = true) @PathParam("field") String fieldName,
+                    @Context UriInfo info, @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+                        aid, "createIndex");
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (resultMap.containsKey("aid"))
+            resultMap.remove("aid");
+        if (!resultMap.isEmpty())
+            return resultMap;
+        MultivaluedMap<String, String> rowParams = info.getQueryParameters();
+        String indexName = "";
+        if (rowParams.getFirst("index_name") != null)
+            indexName = rowParams.getFirst("index_name");
+        PreparedQueryObject query = new PreparedQueryObject();
+        query.appendQueryString("Create index " + indexName + " if not exists on " + keyspace + "."
+                        + tablename + " (" + fieldName + ");");
+        return new JsonResponse(MusicCore.nonKeyRelatedPut(query, "eventual"), "", "").toMap();
+
+    }
+
+    /**
+     * 
+     * @param insObj
+     * @param keyspace
+     * @param tablename
+     * @return
+     * @throws Exception
+     */
+    @POST
+    @Path("/{keyspace}/tables/{tablename}/rows")
+    @ApiOperation(value = "Insert Into Table", response = String.class)
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map<String, Object> insertIntoTable(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    JsonInsert insObj,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("keyspace") String keyspace,
+                    @ApiParam(value = "Table Name",
+                                    required = true) @PathParam("tablename") String tablename,
+                    @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+                        aid, "insertIntoTable");
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (resultMap.containsKey("aid"))
+            resultMap.remove("aid");
+        if (!resultMap.isEmpty()) {
+            return resultMap;
+        }
+        ReturnType result = null;
+        Map<String, Object> valuesMap = insObj.getValues();
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        TableMetadata tableInfo = MusicCore.returnColumnMetadata(keyspace, tablename);
+        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);
+        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 = tableInfo.getColumn(entry.getKey()).getType();
+
+            Object formattedValue = MusicUtil.convertToActualDataType(colType, valueObj);
+            valueString.append("?");
+            queryObject.addValue(formattedValue);
+
+            if (counter == valuesMap.size() - 1) {
+                fieldsString.append(")");
+                valueString.append(")");
+            } else {
+                fieldsString.append(",");
+                valueString.append(",");
+            }
+            counter = counter + 1;
+        }
+
+        queryObject.appendQueryString("INSERT INTO " + keyspace + "." + tablename + " "
+                        + fieldsString + " VALUES " + valueString);
+
+        String ttl = insObj.getTtl();
+        String timestamp = insObj.getTimestamp();
+
+        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));
+        }
+
+        queryObject.appendQueryString(";");
+
+        String consistency = insObj.getConsistencyInfo().get("type");
+        try {
+            if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL)) {
+                result = MusicCore.eventualPut(queryObject);
+            } else if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+                String lockId = insObj.getConsistencyInfo().get("lockId");
+                result = MusicCore.criticalPut(keyspace, tablename, primaryKey, queryObject, lockId,
+                                null);
+            } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
+                result = MusicCore.atomicPut(keyspace, tablename, primaryKey, queryObject, null);
+
+            }
+            return (result != null) ? result.toMap()
+                            : new ReturnType(ResultType.FAILURE,
+                                            "Null result - Please Contact admin").toMap();
+        } catch (Exception ex) {
+            logger.error(ex.getMessage());
+            return new ReturnType(ResultType.FAILURE, ex.getMessage()).toMap();
+        }
+    }
+
+    /**
+     * 
+     * @param insObj
+     * @param keyspace
+     * @param tablename
+     * @param info
+     * @return
+     * @throws Exception
+     */
+    @PUT
+    @Path("/{keyspace}/tables/{tablename}/rows")
+    @ApiOperation(value = "Update Table", response = String.class)
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map<String, Object> updateTable(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    JsonUpdate updateObj,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("keyspace") String keyspace,
+                    @ApiParam(value = "Table Name",
+                                    required = true) @PathParam("tablename") String tablename,
+                    @Context UriInfo info, @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+                        aid, "updateTable");
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (resultMap.containsKey("aid"))
+            resultMap.remove("aid");
+        if (!resultMap.isEmpty()) {
+            return resultMap;
+        }
+        long startTime = System.currentTimeMillis();
+        String operationId = UUID.randomUUID().toString();// just for infoging
+                                                          // purposes.
+        String consistency = updateObj.getConsistencyInfo().get("type");
+        logger.info("--------------Music " + consistency + " update-" + operationId
+                        + "-------------------------");
+        // obtain the field value pairs of the update
+
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        Map<String, Object> valuesMap = updateObj.getValues();
+
+        TableMetadata tableInfo = MusicCore.returnColumnMetadata(keyspace, tablename);
+        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 = tableInfo.getColumn(entry.getKey()).getType();
+            Object valueString = MusicUtil.convertToActualDataType(colType, valueObj);
+            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 = getRowIdentifier(keyspace, tablename, info.getQueryParameters(),
+                        queryObject);
+
+        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
+            String selectQuery = "SELECT *  FROM " + keyspace + "." + tablename + " WHERE "
+                            + rowId.rowIdString + ";";
+            conditionInfo = new MusicCore.Condition(updateObj.getConditions(), selectQuery);
+        }
+
+        ReturnType operationResult = null;
+        long jsonParseCompletionTime = System.currentTimeMillis();
+
+        if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL))
+            operationResult = MusicCore.eventualPut(queryObject);
+        else if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+            String lockId = updateObj.getConsistencyInfo().get("lockId");
+            operationResult = MusicCore.criticalPut(keyspace, tablename, rowId.primarKeyValue,
+                            queryObject, lockId, conditionInfo);
+        }
+        else if (consistency.equalsIgnoreCase("atomic_delete_lock")) {
+            // this function is mainly for the benchmarks
+            operationResult = MusicCore.atomicPutWithDeleteLock(keyspace, tablename,
+                            rowId.primarKeyValue, queryObject, conditionInfo);
+        } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
+            operationResult = MusicCore.atomicPut(keyspace, tablename, rowId.primarKeyValue,
+                            queryObject, conditionInfo);
+        }
+        long actualUpdateCompletionTime = System.currentTimeMillis();
+
+        long endTime = System.currentTimeMillis();
+        String timingString = "Time taken in ms for Music " + consistency + " update-" + operationId
+                        + ":" + "|total operation time:" + (endTime - startTime)
+                        + "|json parsing time:" + (jsonParseCompletionTime - startTime)
+                        + "|update time:" + (actualUpdateCompletionTime - jsonParseCompletionTime)
+                        + "|";
+
+        if (operationResult != null && operationResult.getTimingInfo() != null) {
+            String lockManagementTime = operationResult.getTimingInfo();
+            timingString = timingString + lockManagementTime;
+        }
+        logger.info(timingString);
+        return (operationResult != null) ? operationResult.toMap()
+                        : new ReturnType(ResultType.FAILURE, "Null result - Please Contact admin")
+                                        .toMap();
+    }
+
+    /**
+     * 
+     * @param delObj
+     * @param keyspace
+     * @param tablename
+     * @param info
+     * @return
+     * @throws Exception
+     */
+    @DELETE
+    @Path("/{keyspace}/tables/{tablename}/rows")
+    @ApiOperation(value = "Delete From table", response = String.class)
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map<String, Object> deleteFromTable(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    JsonDelete delObj,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("keyspace") String keyspace,
+                    @ApiParam(value = "Table Name",
+                                    required = true) @PathParam("tablename") String tablename,
+                    @Context UriInfo info, @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+                        aid, "deleteFromTable");
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (resultMap.containsKey("aid"))
+            resultMap.remove("aid");
+        if (!resultMap.isEmpty()) {
+            return resultMap;
+        }
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        StringBuilder columnString = new StringBuilder();
+
+        int counter = 0;
+        ArrayList<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 = getRowIdentifier(keyspace, tablename, info.getQueryParameters(),
+                        queryObject);
+        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
+            String selectQuery = "SELECT *  FROM " + keyspace + "." + tablename + " WHERE "
+                            + rowId.rowIdString + ";";
+            conditionInfo = new MusicCore.Condition(delObj.getConditions(), selectQuery);
+        }
+
+        String consistency = delObj.getConsistencyInfo().get("type");
+
+        ReturnType operationResult = null;
+
+        if (consistency.equalsIgnoreCase(MusicUtil.EVENTUAL))
+            operationResult = MusicCore.eventualPut(queryObject);
+        else if (consistency.equalsIgnoreCase(MusicUtil.CRITICAL)) {
+            String lockId = delObj.getConsistencyInfo().get("lockId");
+            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);
+        }
+        try {
+            return operationResult.toMap();
+        } catch (NullPointerException e) {
+            return new ReturnType(ResultType.FAILURE, e.getMessage()).toMap();
+        }
+    }
+
+    /**
+     * 
+     * @param tabObj
+     * @param keyspace
+     * @param tablename
+     * @throws Exception
+     */
+    @DELETE
+    @Path("/{keyspace}/tables/{tablename}")
+    @ApiOperation(value = "Drop Table", response = String.class)
+
+    public Map<String, Object> dropTable(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    JsonTable tabObj,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("keyspace") String keyspace,
+                    @ApiParam(value = "Table Name",
+                                    required = true) @PathParam("tablename") String tablename,
+                    @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap =
+                        MusicCore.autheticateUser(ns, userId, password, keyspace, aid, "dropTable");
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (resultMap.containsKey("aid"))
+            resultMap.remove("aid");
+        if (!resultMap.isEmpty()) {
+            return resultMap;
+        }
+        String consistency = "eventual";// for now this needs only eventual
+                                        // consistency
+        PreparedQueryObject query = new PreparedQueryObject();
+        query.appendQueryString("DROP TABLE IF EXISTS " + keyspace + "." + tablename + ";");
+        return new JsonResponse(MusicCore.nonKeyRelatedPut(query, consistency), "", "").toMap();
+    }
+
+    /**
+     * 
+     * @param selObj
+     * @param keyspace
+     * @param tablename
+     * @param info
+     * @return
+     */
+    @PUT
+    @Path("/{keyspace}/tables/{tablename}/rows/criticalget")
+    @ApiOperation(value = "Select Critical", response = Map.class)
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map<String, HashMap<String, Object>> selectCritical(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    JsonInsert selObj,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("keyspace") String keyspace,
+                    @ApiParam(value = "Table Name",
+                                    required = true) @PathParam("tablename") String tablename,
+                    @Context UriInfo info, @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+                        aid, "selectCritical");
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (resultMap.containsKey("aid"))
+            resultMap.remove("aid");
+        if (!resultMap.isEmpty()) {
+            logger.error("Error while authentication... ");
+            HashMap<String, Object> tempMap = new HashMap<>();
+            tempMap.putAll(resultMap);
+            Map<String, HashMap<String, Object>> results = new HashMap<>();
+            results.put("Result", tempMap);
+            return results;
+        }
+        String lockId = selObj.getConsistencyInfo().get("lockId");
+
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        StringBuilder rowSpec = new StringBuilder();
+
+        RowIdentifier rowId = getRowIdentifier(keyspace, tablename, info.getQueryParameters(),
+                        queryObject);
+
+        queryObject.appendQueryString(
+                        "SELECT *  FROM " + keyspace + "." + tablename + " WHERE " + rowSpec + ";");
+
+        ResultSet results = null;
+
+        String consistency = selObj.getConsistencyInfo().get("type");
+
+        if (consistency.equalsIgnoreCase("critical")) {
+            results = MusicCore.criticalGet(keyspace, tablename, rowId.primarKeyValue, queryObject,
+                            lockId);
+        } else if (consistency.equalsIgnoreCase("atomic")) {
+            results = MusicCore.atomicGet(keyspace, tablename, rowId.primarKeyValue, queryObject);
+        }
+
+        return MusicCore.marshallResults(results);
+    }
+
+    /**
+     * 
+     * @param keyspace
+     * @param tablename
+     * @param info
+     * @return
+     * @throws Exception
+     */
+    @GET
+    @Path("/{keyspace}/tables/{tablename}/rows")
+    @ApiOperation(value = "Select All or Select Specivic", response = Map.class)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map<String, HashMap<String, Object>> select(
+                    @ApiParam(value = "Major Version",
+                                    required = true) @PathParam("version") String version,
+                    @ApiParam(value = "Minor Version",
+                                    required = false) @HeaderParam("X-minorVersion") String minorVersion,
+                    @ApiParam(value = "Patch Version",
+                                    required = false) @HeaderParam("X-patchVersion") String patchVersion,
+                    @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
+                    @ApiParam(value = "Application namespace",
+                                    required = true) @HeaderParam("ns") String ns,
+                    @ApiParam(value = "userId",
+                                    required = true) @HeaderParam("userId") String userId,
+                    @ApiParam(value = "Password",
+                                    required = true) @HeaderParam("password") String password,
+                    @ApiParam(value = "Keyspace Name",
+                                    required = true) @PathParam("keyspace") String keyspace,
+                    @ApiParam(value = "Table Name",
+                                    required = true) @PathParam("tablename") String tablename,
+                    @Context UriInfo info, @Context HttpServletResponse response) throws Exception {
+        Map<String, Object> resultMap =
+                        MusicCore.autheticateUser(ns, userId, password, keyspace, aid, "select");
+        response.addHeader(xLatestVersion, MusicUtil.getVersion());
+        if (resultMap.containsKey("aid"))
+            resultMap.remove("aid");
+        if (!resultMap.isEmpty()) {
+            logger.error("Error while authentication... ");
+            HashMap<String, Object> tempMap = new HashMap<>();
+            tempMap.putAll(resultMap);
+            Map<String, HashMap<String, Object>> results = new HashMap<>();
+            results.put("Result", tempMap);
+            return results;
+        }
+        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
+            queryObject = selectSpecificQuery(version, minorVersion, patchVersion, aid, ns, userId,
+                            password, keyspace, tablename, info, limit);
+        }
+        ResultSet results = MusicCore.get(queryObject);
+        return MusicCore.marshallResults(results);
+    }
+
+    /**
+     * 
+     * @param keyspace
+     * @param tablename
+     * @param info
+     * @param limit
+     * @return
+     * @throws Exception
+     */
+    public PreparedQueryObject selectSpecificQuery(String version, String minorVersion,
+                    String patchVersion, String aid, String ns, String userId, String password,
+                    String keyspace, String tablename, UriInfo info, int limit) {
+
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        StringBuilder rowIdString = getRowIdentifier(keyspace, tablename, info.getQueryParameters(),
+                        queryObject).rowIdString;
+
+        queryObject.appendQueryString(
+                        "SELECT *  FROM " + keyspace + "." + tablename + " WHERE " + rowIdString);
+
+        if (limit != -1) {
+            queryObject.appendQueryString(" LIMIT " + limit);
+        }
+
+        queryObject.appendQueryString(";");
+        return queryObject;
+
+    }
+
+    /**
+     * 
+     * @param keyspace
+     * @param tablename
+     * @param rowParams
+     * @param queryObject
+     * @return
+     * @throws Exception
+     */
+    private RowIdentifier getRowIdentifier(String keyspace, String tablename,
+                    MultivaluedMap<String, String> rowParams, PreparedQueryObject queryObject) {
+        StringBuilder rowSpec = new StringBuilder();
+        int counter = 0;
+        TableMetadata tableInfo = MusicCore.returnColumnMetadata(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 = tableInfo.getColumn(entry.getKey()).getType();
+            Object formattedValue = MusicUtil.convertToActualDataType(colType, indValue);
+            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);
+    }
+
+}