Example usage for java.sql PreparedStatement executeBatch

List of usage examples for java.sql PreparedStatement executeBatch

  1. HOME
  2. Java
  3. java
  4. java.sql.*
  5. PreparedStatement
  6. executeBatch

Introduction

In this page you can find the example usage for java.sql PreparedStatement executeBatch.

Prototype

int[] executeBatch() throws SQLException;

Source Link

Document

Submits a batch of commands to the database for execution and if all commands execute successfully, returns an array of update counts.

Usage

From source file:org.apache.hadoop.hive.metastore.MyXid.java

@Override
public void addSerdeProps(String dbName, String tblName, String modifyUser, Map<String, String> props)
        throws InvalidOperationException, MetaException {
    Connection con;//from  w ww. jav a 2s .  c o  m
    PreparedStatement ps = null;
    Statement stmt = null;
    boolean success = false;

    dbName = dbName.toLowerCase();
    tblName = tblName.toLowerCase();

    try {
        con = getSegmentConnection(dbName);
    } catch (MetaStoreConnectException e1) {
        LOG.error("add serde props error, db=" + dbName + ", tbl=" + tblName + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    } catch (SQLException e1) {
        LOG.error("add serde props error, db=" + dbName + ", tbl=" + tblName + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    try {
        con.setAutoCommit(false);
        con.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
        stmt = con.createStatement();

        String sql = "select tbls.tbl_id from tbls where " + "tbls.db_name='" + dbName + "' and tbls.tbl_name='"
                + tblName + "'";

        boolean isTblFind = false;
        long tblID = 0;

        ResultSet tblSet = stmt.executeQuery(sql);
        while (tblSet.next()) {
            isTblFind = true;
            tblID = tblSet.getLong(1);
        }

        tblSet.close();

        if (!isTblFind) {
            throw new MetaException("can not find table " + dbName + ":" + tblName);
        }

        Map<String, String> tblParamMap = new HashMap<String, String>();
        Map<String, String> serdeParamMap = new HashMap<String, String>();
        sql = "select param_type, param_key, param_value from table_params where tbl_id=" + tblID
                + " and (param_type='SERDE' or param_type='TBL')";
        ResultSet paramSet = stmt.executeQuery(sql);
        String type = null;
        while (paramSet.next()) {
            type = paramSet.getString(1);
            if (type.equalsIgnoreCase("TBL")) {
                tblParamMap.put(paramSet.getString(2), paramSet.getString(3));
            } else {
                serdeParamMap.put(paramSet.getString(2), paramSet.getString(3));
            }
        }
        paramSet.close();

        boolean containTime = false;
        boolean contailUser = false;
        if (tblParamMap.containsKey("last_modified_time"))
            containTime = true;
        if (tblParamMap.containsKey("last_modified_by"))
            contailUser = true;

        Map<String, String> needUpdateMap = new HashMap<String, String>();
        Map<String, String> needAddMap = new HashMap<String, String>();

        for (Entry<String, String> entry : props.entrySet()) {
            if (serdeParamMap.containsKey(entry.getKey())) {
                needUpdateMap.put(entry.getKey(), entry.getValue());
            } else {
                needAddMap.put(entry.getKey(), entry.getValue());
            }
        }

        if (!needUpdateMap.isEmpty() || containTime || contailUser) {
            ps = con.prepareStatement("update table_params set param_value=? where "
                    + " tbl_id=? and param_type=? and param_key=?");
            for (Entry<String, String> entry : needUpdateMap.entrySet()) {
                ps.setString(1, entry.getValue());
                ps.setLong(2, tblID);
                ps.setString(3, "SERDE");
                ps.setString(4, entry.getKey());
                ps.addBatch();
            }

            if (containTime) {
                ps.setString(1, String.valueOf(System.currentTimeMillis() / 1000));
                ps.setLong(2, tblID);
                ps.setString(3, "TBL");
                ps.setString(4, "last_modified_time");
                ps.addBatch();
            }

            if (contailUser) {
                ps.setString(1, modifyUser);
                ps.setLong(2, tblID);
                ps.setString(3, "TBL");
                ps.setString(4, "last_modified_by");
                ps.addBatch();
            }

            ps.executeBatch();
            ps.close();
        }

        if (!needAddMap.isEmpty() || !containTime || !contailUser) {
            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, "
                    + "param_key, param_value) values(?,?,?,?)");

            for (Map.Entry<String, String> entry : needAddMap.entrySet()) {
                ps.setLong(1, tblID);
                ps.setString(2, "SERDE");
                ps.setString(3, entry.getKey());
                ps.setString(4, entry.getValue());
                ps.addBatch();
            }

            if (!containTime) {
                ps.setLong(1, tblID);
                ps.setString(2, "TBL");
                ps.setString(3, "last_modified_time");
                ps.setString(4, String.valueOf(System.currentTimeMillis() / 1000));
                ps.addBatch();
            }

            if (!contailUser) {
                ps.setLong(1, tblID);
                ps.setString(2, "TBL");
                ps.setString(3, "last_modified_by");
                ps.setString(4, modifyUser);
                ps.addBatch();
            }

            ps.executeBatch();
            ps.close();
        }

        con.commit();
        success = true;
    } catch (SQLException ex) {
        ex.printStackTrace();
        LOG.error("add serde props error, db=" + dbName + ", tbl=" + tblName + ", msg=" + ex.getMessage());
        throw new MetaException(ex.getMessage());
    } finally {
        if (!success) {
            try {
                con.rollback();
            } catch (SQLException e) {
            }
        }

        closeStatement(ps);
        closeStatement(stmt);
        closeConnection(con);
    }

    return;
}

From source file:org.apache.hadoop.hive.metastore.MyXid.java

@Override
public void addSerde(String dbName, String tblName, AddSerdeDesc addSerdeDesc)
        throws InvalidOperationException, MetaException {
    Connection con;/*from  w w w  . ja v a2s . co  m*/
    PreparedStatement ps = null;
    boolean success = false;

    dbName = dbName.toLowerCase();
    tblName = tblName.toLowerCase();

    try {
        con = getSegmentConnection(dbName);
    } catch (MetaStoreConnectException e1) {
        LOG.error("add serde error, db=" + dbName + ", tbl=" + tblName + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    } catch (SQLException e1) {
        LOG.error("add serde error, db=" + dbName + ", tbl=" + tblName + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    try {
        con.setAutoCommit(false);
        con.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);

        ps = con.prepareStatement(
                "select tbl_id, is_compressed, input_format, output_format, serde_lib, tbl_location "
                        + " from tbls where db_name=? and tbl_name=?");

        ps.setString(1, dbName);
        ps.setString(2, tblName);

        boolean isTblFind = false;
        long tblID = 0;
        String serdeLib = null;
        String inputFormat = null;
        String location = null;
        String outputFormat = null;
        boolean isCompressed = false;
        Properties schema = new Properties();

        ResultSet tblSet = ps.executeQuery();
        while (tblSet.next()) {
            isTblFind = true;
            tblID = tblSet.getLong(1);
            isCompressed = tblSet.getBoolean(2);
            inputFormat = tblSet.getString(3);
            outputFormat = tblSet.getString(4);
            location = tblSet.getString(6);
            break;
        }

        serdeLib = addSerdeDesc.getSerdeName();

        tblSet.close();
        ps.close();

        if (!isTblFind) {
            throw new MetaException("can not find table " + dbName + ":" + tblName);
        }

        if (inputFormat == null || inputFormat.length() == 0) {
            inputFormat = org.apache.hadoop.mapred.SequenceFileInputFormat.class.getName();
        }
        schema.setProperty(org.apache.hadoop.hive.metastore.api.Constants.FILE_INPUT_FORMAT, inputFormat);

        if (outputFormat == null || outputFormat.length() == 0) {
            outputFormat = org.apache.hadoop.mapred.SequenceFileOutputFormat.class.getName();
        }
        schema.setProperty(org.apache.hadoop.hive.metastore.api.Constants.FILE_OUTPUT_FORMAT, outputFormat);

        schema.setProperty(org.apache.hadoop.hive.metastore.api.Constants.META_TABLE_NAME, tblName);

        if (location != null) {
            schema.setProperty(org.apache.hadoop.hive.metastore.api.Constants.META_TABLE_LOCATION, location);
        }

        schema.setProperty(org.apache.hadoop.hive.metastore.api.Constants.BUCKET_COUNT, "0");

        if (isCompressed) {
            schema.setProperty(org.apache.hadoop.hive.metastore.api.Constants.COMPRESS, "true");
        } else {
        }

        if (serdeLib == null) {
            throw new MetaException("serde lib for the table " + dbName + ":" + tblName + " is null");
        }

        if (serdeLib != null) {
            schema.setProperty(org.apache.hadoop.hive.serde.Constants.SERIALIZATION_LIB, serdeLib);
        }

        String modifyUser = addSerdeDesc.getUser();
        Map<String, String> tblParamMap = new HashMap<String, String>();
        ps = con.prepareStatement(
                "select param_key, param_value from table_params where tbl_id=? and param_type='TBL'");
        ps.setLong(1, tblID);
        ResultSet paramSet = ps.executeQuery();
        while (paramSet.next()) {
            tblParamMap.put(paramSet.getString(1), paramSet.getString(2));
        }
        paramSet.close();
        ps.close();
        boolean containTime = false;
        boolean contailUser = false;
        if (tblParamMap.containsKey("last_modified_time"))
            containTime = true;
        if (tblParamMap.containsKey("last_modified_by"))
            contailUser = true;

        if (containTime && contailUser) {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");
            ps.setString(1, String.valueOf(System.currentTimeMillis() / 1000));
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_time");
            ps.addBatch();
            ps.setString(1, modifyUser);
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_by");
            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else if (!containTime && !contailUser) {
            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");
            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_time");
            ps.setString(4, String.valueOf(System.currentTimeMillis() / 1000));
            ps.addBatch();

            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_by");
            ps.setString(4, modifyUser);

            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else if (containTime && !contailUser) {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");
            ps.setString(1, String.valueOf(System.currentTimeMillis() / 1000));
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_time");
            ps.addBatch();

            ps.executeBatch();
            ps.close();

            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");

            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_by");
            ps.setString(4, modifyUser);

            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");

            ps.setString(1, modifyUser);
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_by");
            ps.addBatch();

            ps.executeBatch();
            ps.close();

            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");
            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_time");
            ps.setString(4, String.valueOf(System.currentTimeMillis() / 1000));
            ps.addBatch();

            ps.executeBatch();
            ps.close();
        }

        ps = con.prepareStatement(
                "select param_key, param_value from table_params where tbl_id=? and (param_type='SERDE' or param_type='TBL')");
        ps.setLong(1, tblID);

        ResultSet sdParamSet = ps.executeQuery();
        while (sdParamSet.next()) {
            schema.setProperty(sdParamSet.getString(1), sdParamSet.getString(2));
        }
        sdParamSet.close();
        ps.close();

        ps = con.prepareStatement(
                "select column_name, type_name, comment from columns where tbl_id=? order by column_index asc");
        ps.setLong(1, tblID);
        StringBuilder colNameBuf = new StringBuilder();
        StringBuilder colTypeBuf = new StringBuilder();
        List<FieldSchema> colList = new ArrayList<FieldSchema>();

        ResultSet colSet = ps.executeQuery();
        boolean first = true;
        while (colSet.next()) {
            String name = colSet.getString(1);
            String type = colSet.getString(2);
            String comment = colSet.getString(3);

            FieldSchema field = new FieldSchema();
            field.setName(name);
            field.setType(type);
            field.setComment(comment);
            colList.add(field);

            if (!first) {
                colNameBuf.append(",");
                colTypeBuf.append(":");
            }
            colNameBuf.append(colSet.getString(1));
            colTypeBuf.append(colSet.getString(2));

            first = false;
        }

        colSet.close();
        ps.close();

        String colNames = colNameBuf.toString();
        String colTypes = colTypeBuf.toString();
        schema.setProperty(org.apache.hadoop.hive.metastore.api.Constants.META_TABLE_COLUMNS, colNames);
        schema.setProperty(org.apache.hadoop.hive.metastore.api.Constants.META_TABLE_COLUMN_TYPES, colTypes);

        schema.setProperty(org.apache.hadoop.hive.serde.Constants.SERIALIZATION_DDL,
                getDDLFromFieldSchema(tblName, colList));

        Deserializer deserializer = SerDeUtils.lookupDeserializer(serdeLib);
        deserializer.initialize(hiveConf, schema);

        List<FieldSchema> newColList = null;

        try {
            newColList = MetaStoreUtils.getFieldsFromDeserializer(tblName, deserializer);
        } catch (SerDeException e) {
            throw new MetaException("Error in getting fields from serde. " + e.getMessage());
        } catch (MetaException e) {
            throw new MetaException("Error in getting fields from serde." + e.getMessage());
        }

        ps = con.prepareStatement("delete from columns where tbl_id=?");
        ps.setLong(1, tblID);
        ps.executeUpdate();
        ps.close();

        ps = con.prepareStatement("insert into columns(column_index, tbl_id, column_name "
                + ",type_name, comment) values(?,?,?,?,?)");

        long index = 0;

        for (FieldSchema field : newColList) {
            ps.setLong(1, index);
            ps.setLong(2, tblID);
            ps.setString(3, field.getName());
            ps.setString(4, field.getType());
            ps.setString(5, field.getComment());
            ps.addBatch();
            index++;
        }
        ps.executeBatch();
        ps.close();

        if ((addSerdeDesc.getProps() != null) && (addSerdeDesc.getProps().size() > 0)) {
            ps = con.prepareStatement("select param_key, param_value from table_params where tbl_id=? and "
                    + "param_type='SERDE'");
            ps.setLong(1, tblID);
            ResultSet oldParamSet = ps.executeQuery();

            Map<String, String> needUpdateMap = new HashMap<String, String>();
            Map<String, String> needAddMap = new HashMap<String, String>();
            Map<String, String> oldParamMap = new HashMap<String, String>();

            while (oldParamSet.next()) {
                oldParamMap.put(oldParamSet.getString(1), oldParamSet.getString(2));
            }
            oldParamSet.close();
            ps.close();

            for (Map.Entry<String, String> entry : addSerdeDesc.getProps().entrySet()) {
                if (oldParamMap.containsKey(entry.getKey())) {
                    needUpdateMap.put(entry.getKey(), entry.getValue());
                } else {
                    needAddMap.put(entry.getKey(), entry.getValue());
                }
            }

            if (!needAddMap.isEmpty()) {
                ps = con.prepareStatement(
                        "insert into table_params(tbl_id, param_key, param_value, param_type) values(?,?,?,?)");

                for (Map.Entry<String, String> entry : needAddMap.entrySet()) {
                    ps.setLong(1, tblID);
                    ps.setString(2, entry.getKey());
                    ps.setString(3, entry.getValue());
                    ps.setString(4, "SERDE");
                    ps.addBatch();
                }
                ps.executeBatch();
                ps.close();
            }

            if (!needUpdateMap.isEmpty()) {
                ps = con.prepareStatement(
                        "update table_params set param_value=? where tbl_id=? and param_type='SERDE' and param_key=?");

                for (Map.Entry<String, String> entry : needUpdateMap.entrySet()) {
                    ps.setString(1, entry.getValue());
                    ps.setLong(2, tblID);
                    ps.setString(3, entry.getKey());
                    ps.addBatch();
                }
                ps.executeBatch();
                ps.close();
            }
        }

        ps = con.prepareStatement("update tbls set serde_lib=? where tbl_id=?");
        ps.setString(1, addSerdeDesc.getSerdeName());
        ps.setLong(2, tblID);
        ps.executeUpdate();
        ps.close();

        con.commit();
        success = true;
    } catch (Exception ex) {
        LOG.error("add serde error, db=" + dbName + ", tbl=" + tblName + ", msg=" + ex.getMessage());
        ex.printStackTrace();
        throw new MetaException(ex.getMessage());
    }

    finally {
        if (!success) {
            try {
                con.rollback();
            } catch (SQLException e) {
            }
        }

        closeStatement(ps);
        closeConnection(con);
    }

    return;
}

From source file:org.apache.hadoop.hive.metastore.MyXid.java

@Override
public void replaceCols(String dbName, String tblName, String modifyUser, List<FieldSchema> newCols)
        throws InvalidOperationException, MetaException {
    Connection con = null;//from   www.j a v  a2s . c  o  m
    PreparedStatement ps = null;
    boolean success = false;
    dbName = dbName.toLowerCase();
    tblName = tblName.toLowerCase();

    try {
        con = getSegmentConnection(dbName);
    } catch (MetaStoreConnectException e1) {
        LOG.error("replace column error, db=" + dbName + ", tbl=" + tblName + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    } catch (SQLException e1) {
        LOG.error("replace column error, db=" + dbName + ", tbl=" + tblName + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    try {
        con.setAutoCommit(false);
        con.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);

        ps = con.prepareStatement("select tbl_id, tbl_type, tbl_format, pri_part_type, serde_lib"
                + " from tbls where db_name=? and tbl_name=?");

        ps.setString(1, dbName);
        ps.setString(2, tblName);

        String tblType = null;
        String serdeLib = null;
        String tblFormat = null;
        String priPartType = null;
        boolean isPriPart = false;
        boolean isTblFind = false;
        long tblID = 0;

        ResultSet tblSet = ps.executeQuery();
        while (tblSet.next()) {
            isTblFind = true;
            tblID = tblSet.getLong(1);
            tblType = tblSet.getString(2);
            tblFormat = tblSet.getString(3);
            priPartType = tblSet.getString(4);
            serdeLib = tblSet.getString(5);

            isPriPart = priPartType != null;
        }

        tblSet.close();
        ps.close();

        if (!isTblFind) {
            throw new MetaException("can not find table " + dbName + ":" + tblName);
        }

        if (tblType.equalsIgnoreCase("VITURAL_VIEW")) {
            throw new MetaException("view can not replace column ");
        }

        if (!HiveConf.getBoolVar(hiveConf, ConfVars.ALTERSCHEMAACTIVATEREPLACE)) {
            throw new MetaException("replace columns is not supported rightnow");
        }

        if (tblType.equalsIgnoreCase("EXTERNAL_TABLE")
                && !HiveConf.getBoolVar(hiveConf, ConfVars.ALTERSCHEMAACTIVATEEXTTABLE)) {
            throw new MetaException("can not replace columns for a extenal table ");
        }

        if (!tblType.equalsIgnoreCase("EXTERNAL_TABLE")
                && (tblFormat != null && tblFormat.equalsIgnoreCase("text"))
                && (!HiveConf.getBoolVar(hiveConf, ConfVars.ALTERSCHEMAACTIVATETXTTABLE))) {
            throw new MetaException("can not replace columns for a text format table ");
        }

        if (!serdeLib.equals(MetadataTypedColumnsetSerDe.class.getName())
                && !serdeLib.equals(LazySimpleSerDe.class.getName())
                && !serdeLib.equals(ColumnarSerDe.class.getName())
                && !serdeLib.equals(DynamicSerDe.class.getName())
                && !serdeLib.equals(ProtobufSerDe.class.getName())) {
            throw new MetaException(
                    "Replace columns is not supported for this table. SerDe may be incompatible.");
        }

        if (serdeLib.equals("org.apache.hadoop.hive.serde.thrift.columnsetSerDe")) {
            ps = con.prepareStatement("update tbls set serde_lib=? where tbl_id=?");
            ps.setString(1, LazySimpleSerDe.class.getName());
            ps.setLong(2, tblID);
            ps.executeUpdate();
        }

        Map<String, String> tblParamMap = new HashMap<String, String>();
        ps = con.prepareStatement(
                "select param_key, param_value from table_params where tbl_id=? and param_type='TBL'");
        ps.setLong(1, tblID);
        ResultSet paramSet = ps.executeQuery();
        while (paramSet.next()) {
            tblParamMap.put(paramSet.getString(1), paramSet.getString(2));
        }
        paramSet.close();
        ps.close();
        boolean containTime = false;
        boolean contailUser = false;
        if (tblParamMap.containsKey("last_modified_time"))
            containTime = true;
        if (tblParamMap.containsKey("last_modified_by"))
            contailUser = true;

        if (containTime && contailUser) {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");
            ps.setString(1, String.valueOf(System.currentTimeMillis() / 1000));
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_time");
            ps.addBatch();
            ps.setString(1, modifyUser);
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_by");
            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else if (!containTime && !contailUser) {
            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");
            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_time");
            ps.setString(4, String.valueOf(System.currentTimeMillis() / 1000));
            ps.addBatch();

            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_by");
            ps.setString(4, modifyUser);

            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else if (containTime && !contailUser) {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");
            ps.setString(1, String.valueOf(System.currentTimeMillis() / 1000));
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_time");
            ps.addBatch();

            ps.executeBatch();
            ps.close();

            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");

            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_by");
            ps.setString(4, modifyUser);

            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");

            ps.setString(1, modifyUser);
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_by");
            ps.addBatch();

            ps.executeBatch();
            ps.close();

            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");
            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_time");
            ps.setString(4, String.valueOf(System.currentTimeMillis() / 1000));
            ps.addBatch();

            ps.executeBatch();
            ps.close();
        }

        ps = con.prepareStatement("delete from columns where tbl_id=?");
        ps.setLong(1, tblID);
        ps.executeUpdate();
        ps.close();

        ps = con.prepareStatement("insert into columns(column_index, tbl_id, column_name "
                + ",type_name, comment) values(?,?,?,?,?)");
        long index = 0;

        for (FieldSchema field : newCols) {
            ps.setLong(1, index);
            ps.setLong(2, tblID);
            ps.setString(3, field.getName().toLowerCase());
            ps.setString(4, field.getType());
            ps.setString(5, field.getComment());

            ps.addBatch();
            index++;
        }

        ps.executeBatch();
        ps.close();

        con.commit();
        success = true;
    } catch (SQLException ex) {
        ex.printStackTrace();
        LOG.error("replace column error, db=" + dbName + ", tbl=" + tblName + ", msg=" + ex.getMessage());
        throw new MetaException(ex.getMessage());
    } finally {
        if (!success) {
            try {
                con.rollback();
            } catch (SQLException e) {
            }
        }

        closeStatement(ps);
        closeConnection(con);
    }
    return;
}

From source file:org.apache.hadoop.hive.metastore.MyXid.java

@Override
public void addCols(String dbName, String tblName, String modifyUser, List<FieldSchema> newCols)
        throws InvalidOperationException, MetaException, InvalidObjectException {
    if (!MetaStoreUtils.validateColNames(newCols)) {
        throw new InvalidObjectException("new add columns name is not valid object");
    }//from  w ww .  ja  v  a  2 s.c o m

    Connection con = null;
    PreparedStatement ps = null;
    boolean success = false;

    dbName = dbName.toLowerCase();
    tblName = tblName.toLowerCase();

    try {
        con = getSegmentConnection(dbName);
    } catch (MetaStoreConnectException e1) {
        LOG.error("add column error, db=" + dbName + ", tbl=" + tblName + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    } catch (SQLException e1) {
        LOG.error("add column error, db=" + dbName + ", tbl=" + tblName + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    try {
        con.setAutoCommit(false);
        con.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);

        ps = con.prepareStatement("select tbl_id, tbl_type, tbl_format, serde_lib"
                + "  from tbls where tbls.db_name=? and tbls.tbl_name=? ");

        ps.setString(1, dbName);
        ps.setString(2, tblName);

        String tblType = null;
        String serdeLib = null;
        String tblFormat = null;

        boolean isTblFind = false;
        long tblID = 0;

        ResultSet tblSet = ps.executeQuery();
        while (tblSet.next()) {
            isTblFind = true;
            tblID = tblSet.getLong(1);
            tblType = tblSet.getString(2);
            tblFormat = tblSet.getString(3);
            serdeLib = tblSet.getString(4);
        }

        tblSet.close();
        ps.close();

        if (!isTblFind) {
            LOG.error("add column error, db=" + dbName + ", tbl=" + tblName);
            throw new MetaException("can not find table " + dbName + ":" + tblName);
        }

        if (tblFormat == null || tblFormat.isEmpty()) {
            tblFormat = "text";
        }

        if (tblType.equalsIgnoreCase("VITURAL_VIEW")) {
            LOG.error("add column error, db=" + dbName + ", tbl=" + tblName);
            throw new InvalidOperationException("view can not add cloumns");
        }

        if (tblType.equalsIgnoreCase("EXTERNAL_TABLE")
                && !HiveConf.getBoolVar(hiveConf, ConfVars.ALTERSCHEMAACTIVATEEXTTABLE)) {
            LOG.error("add column error, db=" + dbName + ", tbl=" + tblName);
            throw new InvalidOperationException("can not add columns for a extenal table ");
        }

        if (!tblType.equalsIgnoreCase("EXTERNAL_TABLE") && tblFormat.equalsIgnoreCase("text")
                && (!HiveConf.getBoolVar(hiveConf, ConfVars.ALTERSCHEMAACTIVATETXTTABLE))) {
            LOG.error("add column error, db=" + dbName + ", tbl=" + tblName);
            throw new InvalidOperationException("can not add columns for a text format table ");
        }

        if (serdeLib != null && serdeLib.equals(ProtobufSerDe.class.getName())) {
            LOG.error("add column error, db=" + dbName + ", tbl=" + tblName);
            throw new InvalidOperationException("can not add columns for a pb table ");
        }

        if (tblFormat != null
                && (tblFormat.equalsIgnoreCase("column") || tblFormat.equalsIgnoreCase("format"))) {
            for (FieldSchema field : newCols) {
                if (field.getType().equals(Constants.BOOLEAN_TYPE_NAME)) {
                    LOG.error("add column error, db=" + dbName + ", tbl=" + tblName);
                    throw new InvalidOperationException(
                            "format file or column file not support boolean type rightnow");
                }
            }
        }

        Map<String, String> tblParamMap = new HashMap<String, String>();
        ps = con.prepareStatement(
                "select param_key, param_value from table_params where tbl_id=? and param_type='TBL'");
        ps.setLong(1, tblID);
        ResultSet paramSet = ps.executeQuery();
        while (paramSet.next()) {
            tblParamMap.put(paramSet.getString(1), paramSet.getString(2));
        }
        paramSet.close();
        ps.close();
        boolean containTime = false;
        boolean contailUser = false;
        if (tblParamMap.containsKey("last_modified_time"))
            containTime = true;
        if (tblParamMap.containsKey("last_modified_by"))
            contailUser = true;

        if (containTime && contailUser) {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");
            ps.setString(1, String.valueOf(System.currentTimeMillis() / 1000));
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_time");
            ps.addBatch();
            ps.setString(1, modifyUser);
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_by");
            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else if (!containTime && !contailUser) {
            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");
            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_time");
            ps.setString(4, String.valueOf(System.currentTimeMillis() / 1000));
            ps.addBatch();

            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_by");
            ps.setString(4, modifyUser);

            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else if (containTime && !contailUser) {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");
            ps.setString(1, String.valueOf(System.currentTimeMillis() / 1000));
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_time");
            ps.addBatch();

            ps.executeBatch();
            ps.close();

            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");

            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_by");
            ps.setString(4, modifyUser);

            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");

            ps.setString(1, modifyUser);
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_by");
            ps.addBatch();

            ps.executeBatch();
            ps.close();

            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");
            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_time");
            ps.setString(4, String.valueOf(System.currentTimeMillis() / 1000));
            ps.addBatch();

            ps.executeBatch();
            ps.close();
        }

        if (serdeLib != null && serdeLib.equals("org.apache.hadoop.hive.serde.thrift.columnsetSerDe")) {
            ps = con.prepareStatement("delete from columns where tbl_id=?");
            ps.setLong(1, tblID);
            ps.executeUpdate();

            ps = con.prepareStatement(
                    "insert into columns(column_index, tbl_id, column_name, type_name, comment)"
                            + " values(?,?,?,?,?)");
            long index = 0;

            for (FieldSchema field : newCols) {
                ps.setLong(1, index);
                ps.setLong(2, tblID);
                ps.setString(3, field.getName().toLowerCase());
                ps.setString(4, field.getType());
                ps.setString(5, field.getComment());

                ps.addBatch();
                index++;
            }
            ps.executeBatch();
            ps.close();

            ps = con.prepareStatement("update tbls set serde_lib=? where tbl_id=?");
            ps.setString(1, LazySimpleSerDe.class.getName());
            ps.setLong(2, tblID);
            ps.executeUpdate();
            ps.close();
        } else {
            Map<String, Long> colNameMap = new HashMap<String, Long>();
            long maxColIndex = 0;

            ps = con.prepareStatement("select column_name, column_index from "
                    + "columns where tbl_id=? order by column_index asc");
            ps.setLong(1, tblID);

            ResultSet colSet = ps.executeQuery();
            while (colSet.next()) {
                maxColIndex = colSet.getLong(2);
                colNameMap.put(colSet.getString(1), maxColIndex);
            }

            colSet.close();
            ps.close();

            ps = con.prepareStatement(
                    "insert into columns(column_index, tbl_id, column_name, type_name, comment)"
                            + " values(?,?,?,?,?)");

            for (FieldSchema field : newCols) {
                if (colNameMap.containsKey(field.getName())) {
                    LOG.error("add column error, db=" + dbName + ", tbl=" + tblName);
                    throw new MetaException("column name conflict, conflict column name is " + field.getName());
                }

                ps.setLong(1, maxColIndex + 1);
                ps.setLong(2, tblID);
                ps.setString(3, field.getName().toLowerCase());
                ps.setString(4, field.getType());
                ps.setString(5, field.getComment());

                maxColIndex++;
                ps.addBatch();
            }

            ps.executeBatch();
            ps.close();
        }

        con.commit();
        success = true;
    } catch (SQLException ex) {
        throw new MetaException(ex.getMessage());
    } finally {
        if (!success) {
            try {
                con.rollback();
            } catch (SQLException e) {
            }
        }

        closeStatement(ps);
        closeConnection(con);
    }
    return;
}

From source file:org.apache.hadoop.hive.metastore.MyXid.java

@Override
public void renameCols(String dbName, String tblName, RenameColDesc renameColDesc)
        throws InvalidOperationException, MetaException, InvalidObjectException {
    if (!MetaStoreUtils.validateName(renameColDesc.getNewName())) {
        throw new InvalidObjectException("new column name is not valid object " + renameColDesc.getNewName());
    }//from   w  ww . j av a2s  . c o m

    Connection con = null;
    PreparedStatement ps = null;
    boolean success = false;

    dbName = dbName.toLowerCase();
    tblName = tblName.toLowerCase();

    try {
        con = getSegmentConnection(dbName);
    } catch (MetaStoreConnectException e1) {
        LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                + renameColDesc.getNewName() + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    } catch (SQLException e1) {
        LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                + renameColDesc.getNewName() + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    try {
        con.setAutoCommit(false);
        con.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);

        ps = con.prepareStatement("select tbl_id, tbl_type, tbl_format ,pri_part_key "
                + ", sub_part_key, serde_lib from tbls where db_name=? and tbl_name=?");

        ps.setString(1, dbName);
        ps.setString(2, tblName);

        String tblType = null;
        String serdeLib = null;
        String tblFormat = null;
        boolean isPriPart = false;
        boolean isSubPart = false;
        String priPartKey = null;
        String subPartKey = null;

        boolean isTblFind = false;
        long tblID = 0;

        ResultSet tblSet = ps.executeQuery();

        while (tblSet.next()) {
            isTblFind = true;
            tblID = tblSet.getLong(1);
            tblType = tblSet.getString(2);
            tblFormat = tblSet.getString(3);
            priPartKey = tblSet.getString(4);
            subPartKey = tblSet.getString(5);
            serdeLib = tblSet.getString(6);

            isPriPart = priPartKey != null;
            isSubPart = subPartKey != null;
        }

        tblSet.close();
        ps.close();

        if (!isTblFind) {
            LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                    + renameColDesc.getNewName());
            throw new MetaException("can not find table " + dbName + ":" + tblName);
        }

        if (tblFormat == null || tblFormat.isEmpty()) {
            tblFormat = "text";
        }

        if (tblType.equalsIgnoreCase("VITURAL_VIEW")) {
            LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                    + renameColDesc.getNewName());
            throw new MetaException("view can not rename a column");
        }

        if (tblType.equalsIgnoreCase("EXTERNAL_TABLE")
                && !HiveConf.getBoolVar(hiveConf, ConfVars.ALTERSCHEMAACTIVATEEXTTABLE)) {
            LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                    + renameColDesc.getNewName());
            throw new MetaException("can not rename columns for a extenal table ");
        }

        if (!tblType.equalsIgnoreCase("EXTERNAL_TABLE") && tblFormat.equalsIgnoreCase("text")
                && (!HiveConf.getBoolVar(hiveConf, ConfVars.ALTERSCHEMAACTIVATETXTTABLE))) {
            LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                    + renameColDesc.getNewName());
            throw new MetaException("can not rename columns for a text format table ");
        } else if (serdeLib.equals(ProtobufSerDe.class.getName())) {
            LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                    + renameColDesc.getNewName());
            throw new MetaException("can not rename columns for a pb table ");
        } else if ((isPriPart && renameColDesc.getOldName().equalsIgnoreCase(priPartKey))
                || (isSubPart && renameColDesc.getOldName().equalsIgnoreCase(subPartKey))) {
            LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                    + renameColDesc.getNewName());
            throw new MetaException("partition key can not be altered  ");
        }

        String modifyUser = renameColDesc.getUser();
        Map<String, String> tblParamMap = new HashMap<String, String>();
        ps = con.prepareStatement(
                "select param_key, param_value from table_params where tbl_id=? and param_type='TBL'");
        ps.setLong(1, tblID);
        ResultSet paramSet = ps.executeQuery();
        while (paramSet.next()) {
            tblParamMap.put(paramSet.getString(1), paramSet.getString(2));
        }
        paramSet.close();
        ps.close();
        boolean containTime = false;
        boolean contailUser = false;
        if (tblParamMap.containsKey("last_modified_time"))
            containTime = true;
        if (tblParamMap.containsKey("last_modified_by"))
            contailUser = true;

        if (containTime && contailUser) {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");
            ps.setString(1, String.valueOf(System.currentTimeMillis() / 1000));
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_time");
            ps.addBatch();
            ps.setString(1, modifyUser);
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_by");
            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else if (!containTime && !contailUser) {
            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");
            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_time");
            ps.setString(4, String.valueOf(System.currentTimeMillis() / 1000));
            ps.addBatch();

            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_by");
            ps.setString(4, modifyUser);

            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else if (containTime && !contailUser) {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");
            ps.setString(1, String.valueOf(System.currentTimeMillis() / 1000));
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_time");
            ps.addBatch();

            ps.executeBatch();
            ps.close();

            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");

            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_by");
            ps.setString(4, modifyUser);

            ps.addBatch();

            ps.executeBatch();
            ps.close();
        } else {
            ps = con.prepareStatement(
                    "update table_params set param_value=? where tbl_id=? and param_type='TBL' and param_key=?");

            ps.setString(1, modifyUser);
            ps.setLong(2, tblID);
            ps.setString(3, "last_modified_by");
            ps.addBatch();

            ps.executeBatch();
            ps.close();

            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");
            ps.setLong(1, tblID);
            ps.setString(2, "TBL");
            ps.setString(3, "last_modified_time");
            ps.setString(4, String.valueOf(System.currentTimeMillis() / 1000));
            ps.addBatch();

            ps.executeBatch();
            ps.close();
        }

        List<FieldSchema> oldCols = new ArrayList<FieldSchema>();

        String oldName = renameColDesc.getOldName();
        String newName = renameColDesc.getNewName();
        String type = renameColDesc.getType();
        String comment = renameColDesc.getComment();

        boolean colFind = false;

        Map<String, Long> colNameMap = new HashMap<String, Long>();

        long maxColIndex = 0;

        ps = con.prepareStatement("select column_index, column_name, type_name from "
                + "columns where tbl_id=? order by column_index asc");

        ps.setLong(1, tblID);

        ResultSet colSet = ps.executeQuery();

        while (colSet.next()) {
            FieldSchema field = new FieldSchema();
            field.setName(colSet.getString(2));
            field.setType(colSet.getString(3));
            oldCols.add(field);

            maxColIndex = colSet.getLong(1);
            colNameMap.put(colSet.getString(2), maxColIndex);
        }

        colSet.close();
        ps.close();

        Iterator<FieldSchema> iterOldCols = oldCols.iterator();
        while (iterOldCols.hasNext()) {
            FieldSchema col = iterOldCols.next();
            String oldColName = col.getName();

            if (oldColName.equalsIgnoreCase(newName) && !oldColName.equalsIgnoreCase(oldName)) {
                LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                        + renameColDesc.getNewName());
                throw new MetaException("column " + newName + " is exists");
            }

            if (oldColName.equalsIgnoreCase(oldName)) {
                if (!checktype(col, type)) {
                    LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                            + renameColDesc.getNewName());
                    throw new MetaException("column type " + col.getType() + " can not convert to " + type);
                }

                colFind = true;
            }
        }

        if (!colFind) {
            LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                    + renameColDesc.getNewName());
            throw new MetaException("can not find column " + oldName);
        }

        if (type == null) {
            if (comment == null) {
                ps = con.prepareStatement(
                        "update columns set column_name=? " + " where tbl_id=? and column_name=?");
                ps.setString(1, newName.toLowerCase());
                ps.setLong(2, tblID);
                ps.setString(3, oldName);

                ps.executeUpdate();
                ps.close();
            } else {
                ps = con.prepareStatement(
                        "update columns set column_name=?, comment=? " + " where tbl_id=? and column_name=?");
                ps.setString(1, newName.toLowerCase());
                ps.setString(2, comment);
                ps.setLong(3, tblID);
                ps.setString(4, oldName);

                ps.executeUpdate();
                ps.close();
            }
        } else {
            if (comment == null) {
                ps = con.prepareStatement(
                        "update columns set column_name=?, type_name=? " + " where tbl_id=? and column_name=?");
                ps.setString(1, newName);
                ps.setString(2, type);
                ps.setLong(3, tblID);
                ps.setString(4, oldName);

                ps.executeUpdate();
                ps.close();
            } else {
                ps = con.prepareStatement("update columns set column_name=?, type_name=?, comment=? "
                        + " where tbl_id=? and column_name=?");
                ps.setString(1, newName);
                ps.setString(2, type);
                ps.setString(3, comment);
                ps.setLong(4, tblID);
                ps.setString(5, oldName);

                ps.executeUpdate();
                ps.close();
            }
        }

        con.commit();
        success = true;
    } catch (SQLException ex) {
        LOG.error("rename column error, db=" + dbName + ", tbl=" + tblName + ", newname="
                + renameColDesc.getNewName() + ", msg=" + ex.getMessage());
        ex.printStackTrace();
        throw new MetaException(ex.getMessage());
    } finally {
        if (!success) {
            try {
                con.rollback();
            } catch (SQLException e) {
            }
        }

        closeStatement(ps);
        closeConnection(con);
    }
    return;
}

From source file:org.apache.hadoop.hive.metastore.MyXid.java

@Override
public void createTable(Table tbl) throws InvalidObjectException, MetaException, AlreadyExistsException {

    if (tbl == null) {
        throw new InvalidObjectException("unvalid parameters, tbl is null");
    }/*from www . j av  a 2 s  .c  om*/

    if (tbl.getTableType() == null) {
        tbl.setTableType("MANAGED_TABLE");
    }

    if (tbl.getTableType().equalsIgnoreCase("VIRTUAL_VIEW")) {
        jdbcCreateView(tbl);
        return;
    }

    tbl.setDbName(tbl.getDbName().toLowerCase());
    tbl.setTableName(tbl.getTableName().toLowerCase());

    LOG.debug("first, check the name is valid or not");
    if (!MetaStoreUtils.validateName(tbl.getTableName())
            || !MetaStoreUtils.validateColNames(tbl.getSd().getCols())
            || (tbl.getPriPartition() != null
                    && !MetaStoreUtils.validateName(tbl.getPriPartition().getParKey().getName()))
            || (tbl.getSubPartition() != null
                    && !MetaStoreUtils.validateName(tbl.getSubPartition().getParKey().getName()))) {
        throw new InvalidObjectException(tbl.getTableName() + " is not a valid object name");
    }

    long tblID = genTblID(tbl.getDbName(), tbl.getTableName());

    boolean success = false;

    Connection con;
    PreparedStatement ps = null;
    Statement stmt = null;
    Path tblPath = null;
    Warehouse wh = new Warehouse(hiveConf);
    boolean madeDir = false;

    LOG.debug("2, generate table path ");

    if (tbl.getSd().getLocation() == null || tbl.getSd().getLocation().isEmpty()) {
        tblPath = wh.getDefaultTablePath(tbl.getDbName(), tbl.getTableName());
    } else {
        if (tbl.getTableType().equalsIgnoreCase("EXTERNAL_TABLE")) {
            LOG.warn("Location: " + tbl.getSd().getLocation() + "specified for non-external table:"
                    + tbl.getTableName());
        }

        tblPath = wh.getDnsPath(new Path(tbl.getSd().getLocation()));
    }
    tbl.getSd().setLocation(tblPath.toString());

    try {
        con = getSegmentConnection(tbl.getDbName());
    } catch (MetaStoreConnectException e1) {
        LOG.error("create table error, db=" + tbl.getDbName() + ", table=" + tbl.getTableName() + ", msg="
                + e1.getMessage());
        throw new MetaException(e1.getMessage());
    } catch (SQLException e1) {
        LOG.error("create table error, db=" + tbl.getDbName() + ", table=" + tbl.getTableName() + ", msg="
                + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    try {
        con.setAutoCommit(false);
        con.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

        stmt = con.createStatement();

        LOG.debug("1 check the table is exist or not");
        String sql = "select tbl_id from tbls where db_name='" + tbl.getDbName().toLowerCase()
                + "' and tbl_name='" + tbl.getTableName().toLowerCase() + "'";

        boolean isTblFind = false;
        ResultSet checkTblSet = stmt.executeQuery(sql);

        while (checkTblSet.next()) {
            isTblFind = true;
            break;
        }
        checkTblSet.close();

        if (isTblFind) {
            throw new AlreadyExistsException(
                    "table " + tbl.getDbName() + ":" + tbl.getTableName() + " has exist");
        }

        LOG.debug("2 insert into tbls");

        ps = con.prepareStatement("INSERT INTO TBLS(tbl_id, is_compressed, retention, tbl_type, db_name, "
                + "tbl_name, tbl_owner, tbl_format"
                + ", pri_part_type, sub_part_type, pri_part_key, sub_part_key, input_format, output_format"
                + ", serde_name, serde_lib, tbl_location, tbl_comment)"
                + " values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");

        StorageDescriptor sd = tbl.getSd();
        if (sd == null || sd.getSerdeInfo() == null) {
            throw new MetaException("storage descriptor of table " + tbl.getTableName() + " is null");
        }

        SerDeInfo sdInfo = sd.getSerdeInfo();

        ps.setLong(1, tblID);
        ps.setBoolean(2, sd.isCompressed());
        ps.setLong(3, tbl.getRetention());
        if (tbl.getParameters() != null && tbl.getParameters().get("EXTERNAL") != null
                && tbl.getParameters().get("EXTERNAL").equalsIgnoreCase("TRUE")) {
            ps.setString(4, "EXTERNAL_TABLE");
        } else {
            ps.setString(4, tbl.getTableType());
        }
        ps.setString(5, tbl.getDbName());
        ps.setString(6, tbl.getTableName());
        ps.setString(7, tbl.getOwner());

        if (tbl.getParameters() == null) {
            ps.setString(8, null);
        } else {
            ps.setString(8, tbl.getParameters().get("type"));
        }

        Partition priPart = tbl.getPriPartition();
        Partition subPart = tbl.getSubPartition();
        if (priPart != null) {
            ps.setString(11, priPart.getParKey().getName());
            ps.setString(9, priPart.getParType());
        } else {
            ps.setString(11, null);
            ps.setString(9, null);
        }

        if (subPart != null) {
            ps.setString(12, subPart.getParKey().getName());
            ps.setString(10, subPart.getParType());
        } else {
            ps.setString(12, null);
            ps.setString(10, null);
        }

        ps.setString(13, sd.getInputFormat());
        ps.setString(14, sd.getOutputFormat());
        ps.setString(15, sdInfo.getName());
        ps.setString(16, sdInfo.getSerializationLib());
        ps.setString(17, sd.getLocation());

        if (tbl.getParameters() == null) {
            ps.setString(18, null);
        } else {
            ps.setString(18, tbl.getParameters().get("comment"));
        }

        ps.executeUpdate();

        ps.close();

        LOG.debug("3 insert into partitions");
        if (priPart != null) {
            ps = con.prepareStatement(
                    "INSERT INTO PARTITIONS(level, tbl_id," + "part_name, part_values) values(?,?,?,?)");

            Map<String, List<String>> partSpaceMap = priPart.getParSpaces();

            for (Map.Entry<String, List<String>> entry : partSpaceMap.entrySet()) {
                ps.setInt(1, 0);
                ps.setLong(2, tblID);
                ps.setString(3, entry.getKey());
                if (entry.getValue() != null) {
                    Array spaceArray = con.createArrayOf("varchar", entry.getValue().toArray());
                    ps.setArray(4, spaceArray);
                } else {
                    ps.setArray(4, null);
                }

                ps.addBatch();
            }
            ps.executeBatch();
            ps.close();
        }

        if (subPart != null) {
            ps = con.prepareStatement(
                    "INSERT INTO PARTITIONS(level, tbl_id," + "part_name, part_values) values(?,?,?,?)");

            Map<String, List<String>> partSpaceMap = subPart.getParSpaces();

            for (Map.Entry<String, List<String>> entry : partSpaceMap.entrySet()) {
                ps.setInt(1, 1);
                ps.setLong(2, tblID);
                ps.setString(3, entry.getKey());

                if (entry.getValue() != null) {
                    Array spaceArray = con.createArrayOf("varchar", entry.getValue().toArray());
                    ps.setArray(4, spaceArray);
                } else {
                    ps.setArray(4, null);
                }

                ps.addBatch();
            }
            ps.executeBatch();
            ps.close();
        }

        LOG.debug("4 insert into columns");
        ps = con.prepareStatement("INSERT INTO COLUMNS(column_index, tbl_id, column_name, type_name, comment) "
                + " values(?,?,?,?,?)");

        List<FieldSchema> fieldList = sd.getCols();
        int fieldSize = fieldList.size();

        for (int i = 0; i < fieldSize; i++) {
            FieldSchema field = fieldList.get(i);
            ps.setInt(1, i);
            ps.setLong(2, tblID);
            ps.setString(3, field.getName().toLowerCase());
            ps.setString(4, field.getType());
            ps.setString(5, field.getComment());

            ps.addBatch();
        }

        ps.executeBatch();
        ps.close();

        LOG.debug("5  insert into parameters");

        boolean createExtDirIfNotExist = true;
        if (tbl.getParametersSize() > 0) {
            String createExtDirIfNotExistStr = tbl.getParameters().get("hive.exttable.createdir.ifnotexist");
            LOG.info("XXcreateExtDirIfNotExistStr=" + createExtDirIfNotExistStr);
            if (createExtDirIfNotExistStr != null && createExtDirIfNotExistStr.equalsIgnoreCase("false")) {
                createExtDirIfNotExist = false;
            }
            tbl.getParameters().remove("hive.exttable.createdir.ifnotexist");
        }

        if (tbl.getParametersSize() > 0 || sd.getParametersSize() > 0
                || sd.getSerdeInfo().getParametersSize() > 0 || sd.getNumBuckets() > -1) {
            ps = con.prepareStatement("insert into table_params(tbl_id, param_type, param_key, param_value) "
                    + " values(?,?,?,?)");
            if (tbl.getParametersSize() > 0) {

                for (Map.Entry<String, String> entry : tbl.getParameters().entrySet()) {
                    if (entry.getKey().equalsIgnoreCase("type") || entry.getKey().equalsIgnoreCase("comment"))
                        continue;
                    ps.setLong(1, tblID);
                    ps.setString(2, "TBL");
                    ps.setString(3, entry.getKey());
                    ps.setString(4, entry.getValue());

                    ps.addBatch();
                }
            }

            if (sd.getParametersSize() > 0) {
                for (Map.Entry<String, String> entry : sd.getParameters().entrySet()) {
                    ps.setLong(1, tblID);
                    ps.setString(2, "SD");
                    ps.setString(3, entry.getKey());
                    ps.setString(4, entry.getValue());

                    ps.addBatch();
                }
            }

            if (sd.getSerdeInfo().getParametersSize() > 0) {
                for (Map.Entry<String, String> entry : sd.getSerdeInfo().getParameters().entrySet()) {
                    ps.setLong(1, tblID);
                    ps.setString(2, "SERDE");
                    ps.setString(3, entry.getKey());
                    ps.setString(4, entry.getValue());

                    ps.addBatch();
                }
            }

            if (sd.getNumBuckets() > -1) {
                ps.setLong(1, tblID);
                ps.setString(2, "SD");
                ps.setString(3, "NUM_BUCKETS");
                ps.setString(4, String.valueOf(sd.getNumBuckets()));
                ps.addBatch();
            }

            ps.executeBatch();
            ps.close();
        }

        if (tbl.getSd().getBucketCols() != null && !tbl.getSd().getBucketCols().isEmpty()) {
            ps = con.prepareStatement(
                    "insert into bucket_cols(tbl_id, bucket_col_name, col_index) values(?,?,?)");
            int index = 0;
            for (String col : tbl.getSd().getBucketCols()) {
                ps.setLong(1, tblID);
                ps.setString(2, col.toLowerCase());
                ps.setInt(3, index);
                index++;
                ps.addBatch();
            }

            ps.executeBatch();
            ps.close();
        }

        if (tbl.getSd().getSortCols() != null && !tbl.getSd().getSortCols().isEmpty()) {
            ps = con.prepareStatement(
                    "insert into sort_cols(tbl_id, sort_column_name, sort_order, col_index) values(?,?,?,?)");
            int index = 0;
            for (Order o : tbl.getSd().getSortCols()) {
                ps.setLong(1, tblID);
                ps.setString(2, o.getCol());
                ps.setInt(3, o.getOrder());
                ps.setInt(4, index);
                index++;
                ps.addBatch();
            }

            ps.executeBatch();
            ps.close();
        }

        LOG.debug("make hdfs directory for table");

        if (createExtDirIfNotExist && tblPath != null) {
            if (!wh.isDir(tblPath)) {
                if (!wh.mkdirs(tblPath)) {
                    throw new MetaException(tblPath + " is not a directory or unable to create one");
                }
                madeDir = true;
            }

            if (tbl.getPriPartition() != null) {
                Set<String> priPartNames = tbl.getPriPartition().getParSpaces().keySet();

                Set<String> subPartNames = null;
                if (tbl.getSubPartition() != null) {
                    subPartNames = tbl.getSubPartition().getParSpaces().keySet();
                }

                List<Path> partPaths = Warehouse.getPartitionPaths(tblPath, priPartNames, subPartNames);

                for (Path partPath : partPaths) {
                    if (!wh.mkdirs(partPath)) {
                        throw new MetaException(
                                "Partition path " + partPath + " is not a directory or unable to create one.");
                    }
                }
            }
        }

        con.commit();

        success = true;
    } catch (SQLException sqlex) {
        LOG.error("create table error db=" + tbl.getDbName() + ", table=" + tbl.getTableName() + ",msg="
                + sqlex.getMessage());
        sqlex.printStackTrace();
        throw new MetaException(sqlex.getMessage());
    } finally {
        if (!success) {
            try {
                con.rollback();
            } catch (SQLException e) {
            }

            if (madeDir) {
                wh.deleteDir(tblPath, true);
            }
        }

        closeStatement(stmt);
        closeStatement(ps);
        closeConnection(con);
    }

    return;
}

From source file:org.apache.hadoop.hive.metastore.MyXid.java

@Override
public boolean revokeAuthOnTbl(String who, List<String> privileges, String db, String tbl)
        throws NoSuchObjectException, InvalidObjectException, MetaException {
    Connection con = null;/* w  w  w .  j a v  a2 s  .  co  m*/
    ;
    Statement ps = null;
    boolean success = false;
    PreparedStatement pss = null;

    who = who.toLowerCase();
    db = db.toLowerCase();
    tbl = tbl.toLowerCase();

    if (privileges == null) {
        throw new InvalidObjectException("No privileges are given!");
    }

    try {
        con = getGlobalConnection();
    } catch (MetaStoreConnectException e1) {
        LOG.error("revoke auth on tbl error, who=" + who + ", db=" + db + ", tbl=" + tbl + ", msg="
                + e1.getMessage());
        throw new MetaException(e1.getMessage());
    } catch (SQLException e1) {
        LOG.error("revoke auth on tbl error, who=" + who + ", db=" + db + ", tbl=" + tbl + ", msg="
                + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    try {
        Map<String, TblPrivDesc> tblPrivMap = new HashMap<String, TblPrivDesc>();
        con.setAutoCommit(false);
        con.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);

        ps = con.createStatement();
        String sql = null;
        StringBuilder sb = new StringBuilder();
        int size = tbl.length();
        for (int i = 0; i < size; i++) {
            if (tbl.charAt(i) != '\'') {
                sb.append(tbl.charAt(i));
            }
        }

        tbl = sb.toString();

        tbl = tbl.replace('*', '%');

        if (tbl == null || tbl.isEmpty() || tbl.equals(".*") || tbl.equals("*")) {
            sql = "select alter_priv, create_priv, delete_priv "
                    + ",drop_priv, index_priv, insert_priv, select_priv, update_priv, tbl_name"
                    + " from tblpriv where user_name='" + who + "' and db_name='" + db + "'";
        } else {
            sql = "select alter_priv, create_priv, delete_priv "
                    + ",drop_priv, index_priv, insert_priv, select_priv, update_priv, tbl_name"
                    + " from tblpriv where user_name='" + who + "' and db_name='" + db + "' and tbl_name like '"
                    + tbl + "'";
        }

        ResultSet privSet = ps.executeQuery(sql);

        while (privSet.next()) {
            TblPrivDesc privDesc = new TblPrivDesc();

            privDesc.alterPriv = privSet.getBoolean(1);
            privDesc.createPriv = privSet.getBoolean(2);
            privDesc.deletePriv = privSet.getBoolean(3);
            privDesc.dropPriv = privSet.getBoolean(4);
            privDesc.indexPriv = privSet.getBoolean(5);
            privDesc.insertPriv = privSet.getBoolean(6);
            privDesc.selPriv = privSet.getBoolean(7);
            privDesc.updatePriv = privSet.getBoolean(8);
            String tblName = privSet.getString(9);

            tblPrivMap.put(tblName, privDesc);
        }

        privSet.close();

        if (tblPrivMap.isEmpty()) {
            LOG.error("revoke auth on tbl error, who=" + who + ", db=" + db + ", tbl=" + tbl);
            throw new NoSuchObjectException(
                    "User " + who + " does not have privileges on table: " + tbl + " in db: " + db);
        }

        boolean selPriv = true;
        boolean insertPriv = true;
        boolean createPriv = true;
        boolean dropPriv = true;
        boolean deletePriv = true;
        boolean alterPriv = true;
        boolean updatePriv = true;
        boolean indexPriv = true;

        for (String priv : privileges) {
            if (priv.equals("TOK_SELECT_PRI")) {
                selPriv = false;
            } else if (priv.equals("TOK_INSERT_PRI")) {
                insertPriv = false;
            } else if (priv.equals("TOK_CREATE_PRI")) {
                createPriv = false;
            } else if (priv.equals("TOK_DROP_PRI")) {
                dropPriv = false;
            } else if (priv.equals("TOK_DELETE_PRI")) {
                deletePriv = false;
            } else if (priv.equals("TOK_ALTER_PRI")) {
                alterPriv = false;
            } else if (priv.equals("TOK_UPDATE_PRI")) {
                updatePriv = false;
            } else if (priv.equals("TOK_INDEX_PRI")) {
                indexPriv = false;
            }

            else if (priv.equals("TOK_ALL_PRI")) {
                selPriv = false;
                insertPriv = false;
                createPriv = false;
                dropPriv = false;
                deletePriv = false;
                alterPriv = false;
                updatePriv = false;
                indexPriv = false;
            } else {
                throw new InvalidObjectException("Privilege does not exist: " + priv);
            }
        }

        Collection<TblPrivDesc> tblPrivColl = tblPrivMap.values();
        if (!alterPriv) {
            for (TblPrivDesc entry : tblPrivColl) {
                entry.alterPriv = false;
            }
        }

        if (!createPriv) {
            for (TblPrivDesc entry : tblPrivColl) {
                entry.createPriv = false;
            }
        }

        if (!deletePriv) {
            for (TblPrivDesc entry : tblPrivColl) {
                entry.deletePriv = false;
            }
        }

        if (!dropPriv) {
            for (TblPrivDesc entry : tblPrivColl) {
                entry.dropPriv = false;
            }
        }

        if (!indexPriv) {
            for (TblPrivDesc entry : tblPrivColl) {
                entry.indexPriv = false;
            }
        }

        if (!insertPriv) {
            for (TblPrivDesc entry : tblPrivColl) {
                entry.insertPriv = false;
            }
        }

        if (!selPriv) {
            for (TblPrivDesc entry : tblPrivColl) {
                entry.selPriv = false;
            }
        }

        if (!updatePriv) {
            for (TblPrivDesc entry : tblPrivColl) {
                entry.updatePriv = false;
            }
        }

        pss = con.prepareStatement("update tblpriv set alter_priv=?, create_priv=?,  "
                + " delete_priv=?, drop_priv=?, index_priv=?, insert_priv=?, select_priv=?,"
                + " update_priv=? where user_name=? and db_name=? and tbl_name=?");

        for (Entry<String, TblPrivDesc> entry : tblPrivMap.entrySet()) {

            pss.setBoolean(1, entry.getValue().alterPriv);
            pss.setBoolean(2, entry.getValue().createPriv);

            pss.setBoolean(3, entry.getValue().deletePriv);
            pss.setBoolean(4, entry.getValue().dropPriv);
            pss.setBoolean(5, entry.getValue().indexPriv);
            pss.setBoolean(6, entry.getValue().insertPriv);
            pss.setBoolean(7, entry.getValue().selPriv);

            pss.setBoolean(8, entry.getValue().updatePriv);
            pss.setString(9, who);
            pss.setString(10, db);
            pss.setString(11, entry.getKey());

            pss.addBatch();
        }

        pss.executeBatch();

        con.commit();
        success = true;
    } catch (SQLException ex) {
        LOG.error("revoke auth on tbl error, who=" + who + ", db=" + db + ", tbl=" + tbl + ", msg="
                + ex.getMessage());
        ex.printStackTrace();
        throw new MetaException(ex.getMessage());
    } finally {
        if (!success) {
            try {
                con.rollback();
            } catch (SQLException e) {
            }
        }

        closeStatement(ps);
        closeStatement(pss);
        closeConnection(con);
    }

    return success;
}

From source file:org.apache.hadoop.hive.metastore.MyXid.java

@Override
public boolean grantAuthOnTbl(String forWho, List<String> privileges, String db, String tbl)
        throws NoSuchObjectException, InvalidObjectException, MetaException {
    Connection con = null;/*from  w  w w .  j  a v  a2 s.co  m*/
    ;
    Statement ps = null;
    boolean success = false;
    PreparedStatement pss = null;

    success = false;
    forWho = forWho.toLowerCase();
    db = db.toLowerCase();
    tbl = tbl.toLowerCase();

    if (privileges == null) {
        throw new InvalidObjectException("No privileges are given!");
    }

    try {
        con = getSegmentConnection(db);
    } catch (MetaStoreConnectException e1) {
        LOG.error("grant auth on db error, forWho=" + forWho + ", db=" + db + ", tbl=" + tbl + ", msg="
                + e1.getMessage());
        throw new MetaException("can not find db:" + db);
    } catch (SQLException e1) {
        LOG.error("grant auth on db error, forWho=" + forWho + ", db=" + db + ", tbl=" + tbl + ", msg="
                + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    Set<String> tblNames = new HashSet<String>();

    try {
        ps = con.createStatement();
        String sql = null;
        StringBuilder sb = new StringBuilder();
        int size = tbl.length();
        for (int i = 0; i < size; i++) {
            if (tbl.charAt(i) != '\'') {
                sb.append(tbl.charAt(i));
            }
        }

        tbl = sb.toString();

        if (tbl == null || tbl.isEmpty() || tbl.equals(".*") || tbl.equals("*")) {
            sql = "select tbl_name from tbls" + " where  tbls.db_name='" + db.toLowerCase() + "'";
        } else {
            tbl = tbl.replace('*', '%');

            sql = "select tbl_name from tbls" + " where  tbls.db_name='" + db + "' and tbls.tbl_name like '"
                    + tbl + "'";
        }

        LOG.debug("SQL is " + sql);

        ResultSet tblSet = ps.executeQuery(sql);
        while (tblSet.next()) {
            String tblName = tblSet.getString(1);
            tblNames.add(tblName);
        }

        tblSet.close();

        con.commit();
        success = true;
    } catch (SQLException ex) {
        ex.printStackTrace();
        LOG.error("grant auth on db error, forWho=" + forWho + ", db=" + db + ", tbl=" + tbl + ", msg="
                + ex.getMessage());
        LOG.error(ex.getMessage());
    } finally {

        closeStatement(ps);
        closeConnection(con);
    }

    if (tblNames.isEmpty()) {
        throw new NoSuchObjectException("Table does not exist: " + tbl + " in db: " + db);
    }

    try {
        con = getGlobalConnection();
    } catch (MetaStoreConnectException e1) {
        LOG.error("grant auth on db error, forWho=" + forWho + ", db=" + db + ", tbl=" + tbl + ", msg="
                + e1.getMessage());
        throw new MetaException(e1.getMessage());
    } catch (SQLException e1) {
        LOG.error("grant auth on db error, forWho=" + forWho + ", db=" + db + ", tbl=" + tbl + ", msg="
                + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    try {
        con.setAutoCommit(false);
        con.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
        ps = con.createStatement();
        String sql = null;
        StringBuilder sb = new StringBuilder();
        int size = tbl.length();
        for (int i = 0; i < size; i++) {
            if (tbl.charAt(i) != '\'') {
                sb.append(tbl.charAt(i));
            }
        }

        tbl = sb.toString();

        if (tbl == null || tbl.isEmpty() || tbl.equals(".*") || tbl.equals("*")) {
            sql = "select tbl_name, alter_priv, create_priv, delete_priv "
                    + ",drop_priv, index_priv, insert_priv, select_priv, " + " update_priv from tblpriv"
                    + " where db_name='" + db.toLowerCase() + "' and user_name='" + forWho + "'";
        } else {
            tbl = tbl.replace('*', '%');

            sql = "select tbl_name, alter_priv, create_priv, delete_priv "
                    + ",drop_priv, index_priv, insert_priv, select_priv, " + " update_priv from tblpriv"
                    + " where db_name='" + db + "' and tbl_name like '" + tbl + "'" + " and user_name='"
                    + forWho + "'";
        }

        LOG.debug("SQL is " + sql);

        ResultSet tblSet = ps.executeQuery(sql);

        Map<String, TblPrivDesc> tblPrivMap = new HashMap<String, TblPrivDesc>();

        while (tblSet.next()) {
            String tblName = tblSet.getString(1);

            TblPrivDesc privDesc = new TblPrivDesc();
            privDesc.alterPriv = tblSet.getBoolean(2);
            privDesc.createPriv = tblSet.getBoolean(3);
            privDesc.deletePriv = tblSet.getBoolean(4);
            privDesc.dropPriv = tblSet.getBoolean(5);
            privDesc.indexPriv = tblSet.getBoolean(6);
            privDesc.insertPriv = tblSet.getBoolean(7);
            privDesc.selPriv = tblSet.getBoolean(8);
            privDesc.updatePriv = tblSet.getBoolean(9);

            tblPrivMap.put(tblName, privDesc);
        }

        tblSet.close();

        boolean selPriv = false;
        boolean insertPriv = false;
        boolean createPriv = false;
        boolean dropPriv = false;
        boolean deletePriv = false;
        boolean alterPriv = false;
        boolean updatePriv = false;
        boolean indexPriv = false;

        for (String priv : privileges) {
            if (priv.equals("TOK_SELECT_PRI")) {
                selPriv = true;
            } else if (priv.equals("TOK_INSERT_PRI")) {
                insertPriv = true;
            } else if (priv.equals("TOK_CREATE_PRI")) {
                createPriv = true;
            } else if (priv.equals("TOK_DROP_PRI")) {
                dropPriv = true;
            } else if (priv.equals("TOK_DELETE_PRI")) {
                deletePriv = true;
            } else if (priv.equals("TOK_ALTER_PRI")) {
                alterPriv = true;
            } else if (priv.equals("TOK_UPDATE_PRI")) {
                updatePriv = true;
            } else if (priv.equals("TOK_INDEX_PRI")) {
                indexPriv = true;
            } else if (priv.equals("TOK_ALL_PRI")) {
                selPriv = true;
                insertPriv = true;
                createPriv = true;
                dropPriv = true;
                deletePriv = true;
                alterPriv = true;
                updatePriv = true;
                indexPriv = true;
            } else {
                throw new InvalidObjectException("Privilege does not exist: " + priv);
            }
        }

        if (!tblPrivMap.isEmpty()) {
            Collection<TblPrivDesc> tblPrivColl = tblPrivMap.values();
            if (alterPriv) {
                for (TblPrivDesc entry : tblPrivColl) {
                    entry.alterPriv = true;
                }
            }

            if (createPriv) {
                for (TblPrivDesc entry : tblPrivColl) {
                    entry.createPriv = true;
                }
            }

            if (deletePriv) {
                for (TblPrivDesc entry : tblPrivColl) {
                    entry.deletePriv = true;
                }
            }

            if (dropPriv) {
                for (TblPrivDesc entry : tblPrivColl) {
                    entry.dropPriv = true;
                }
            }

            if (indexPriv) {
                for (TblPrivDesc entry : tblPrivColl) {
                    entry.indexPriv = true;
                }
            }

            if (insertPriv) {
                for (TblPrivDesc entry : tblPrivColl) {
                    entry.insertPriv = true;
                }
            }

            if (selPriv) {
                for (TblPrivDesc entry : tblPrivColl) {
                    entry.selPriv = true;
                }
            }

            if (updatePriv) {
                for (TblPrivDesc entry : tblPrivColl) {
                    entry.updatePriv = true;
                }
            }

            pss = con.prepareStatement("update tblpriv set alter_priv=?, create_priv=?,  "
                    + " delete_priv=?, drop_priv=?, index_priv=?, insert_priv=?, select_priv=?,"
                    + " update_priv=? where user_name=? and db_name=? and tbl_name=? ");

            for (Entry<String, TblPrivDesc> entry : tblPrivMap.entrySet()) {

                pss.setBoolean(1, entry.getValue().alterPriv);
                pss.setBoolean(2, entry.getValue().createPriv);

                pss.setBoolean(3, entry.getValue().deletePriv);
                pss.setBoolean(4, entry.getValue().dropPriv);
                pss.setBoolean(5, entry.getValue().indexPriv);
                pss.setBoolean(6, entry.getValue().insertPriv);
                pss.setBoolean(7, entry.getValue().selPriv);

                pss.setBoolean(8, entry.getValue().updatePriv);

                pss.setString(9, forWho);
                pss.setString(10, db);
                pss.setString(11, entry.getKey());

                pss.addBatch();
            }

            pss.executeBatch();
        }

        pss = con.prepareStatement("insert into tblpriv(alter_priv, create_priv,"
                + "delete_priv, drop_priv, index_priv, insert_priv, select_priv,"
                + " update_priv, user_name, db_name, tbl_name) values(?,?,?,?,?,?,?,?,?,?,?)");
        int needInsertCount = 0;

        for (String tblName : tblNames) {
            if (!tblPrivMap.containsKey(tblName)) {
                pss.setBoolean(1, alterPriv);
                pss.setBoolean(2, createPriv);
                pss.setBoolean(3, deletePriv);
                pss.setBoolean(4, dropPriv);
                pss.setBoolean(5, indexPriv);
                pss.setBoolean(6, insertPriv);
                pss.setBoolean(7, selPriv);

                pss.setBoolean(8, updatePriv);
                pss.setString(9, forWho);
                pss.setString(10, db);
                pss.setString(11, tblName);

                pss.addBatch();

                needInsertCount++;
            }
        }

        if (needInsertCount > 0) {
            pss.executeBatch();
        }

        con.commit();
        success = true;
    } catch (SQLException ex) {
        ex.printStackTrace();
        LOG.error("grant auth on db error, forWho=" + forWho + ", db=" + db + ", tbl=" + tbl + ", msg="
                + ex.getMessage());
        LOG.error(ex.getMessage());
    } finally {
        if (!success) {
            try {
                con.rollback();
            } catch (SQLException e) {
            }
        }
        closeStatement(ps);
        closeStatement(pss);
        closeConnection(con);
    }

    return success;
}

From source file:org.apache.hadoop.hive.metastore.MyXid.java

public void addPartition(String dbName, String tblName, AddPartitionDesc addPartitionDesc)
        throws InvalidObjectException, MetaException {
    boolean success = false;

    Connection con = null;/*from  w ww . j a v a2 s  .  c o  m*/
    PreparedStatement ps = null;
    Statement stmt = null;
    dbName = dbName.toLowerCase();
    tblName = tblName.toLowerCase();

    boolean isPathMaked = false;
    ArrayList<Path> pathToMake = new ArrayList<Path>();
    Warehouse wh = new Warehouse(hiveConf);

    long tblID = 0;

    try {
        con = getSegmentConnection(dbName);
    } catch (MetaStoreConnectException e1) {
        LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                + addPartitionDesc.getLevel() + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    } catch (SQLException e1) {
        LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                + addPartitionDesc.getLevel() + ", msg=" + e1.getMessage());
        throw new MetaException(e1.getMessage());
    }

    try {
        con.setAutoCommit(false);
        con.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
        stmt = con.createStatement();

        String tblType = null;
        boolean hasPriPart = false;
        boolean hasSubPart = false;
        String priPartKey = null;
        String subPartKey = null;
        String priPartType = null;
        String subPartType = null;

        String priKeyType = null;
        String subKeyType = null;
        ResultSet tblSet = null;
        boolean isTblFind = false;
        boolean isColFind = false;

        String tblFormat = null;
        String tblLocation = null;

        PrimitiveTypeInfo pti = null;
        ObjectInspector StringIO = null;
        ObjectInspector ValueIO = null;
        ObjectInspectorConverters.Converter converter1 = null;
        ObjectInspectorConverters.Converter converter2 = null;

        ArrayList<String> partToAdd = new ArrayList<String>();
        String sql = null;

        HiveConf hconf = (HiveConf) hiveConf;
        boolean externalPartition = hconf.getBoolVar(HiveConf.ConfVars.HIVESUPPORTEXTERNALPARTITION);

        if (addPartitionDesc.getLevel() == 0) {
            sql = "SELECT tbl_id, tbl_type, pri_part_type, pri_part_key, tbl_format, tbl_location"
                    + " from TBLS where db_name='" + dbName + "' and tbl_name='" + tblName + "'";

            tblSet = stmt.executeQuery(sql);
            isTblFind = false;

            while (tblSet.next()) {
                isTblFind = true;
                tblID = tblSet.getLong(1);
                tblType = tblSet.getString(2);
                priPartKey = tblSet.getString(4);
                priPartType = tblSet.getString(3);
                tblFormat = tblSet.getString(5);
                tblLocation = tblSet.getString(6);

                if (priPartType != null && !priPartType.isEmpty()) {
                    hasPriPart = true;
                }
                break;
            }
            tblSet.close();

            if (!isTblFind) {
                LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                        + addPartitionDesc.getLevel() + ", msg=" + "can not find table " + dbName + ":"
                        + tblName);

                throw new MetaException("can not find table " + dbName + ":" + tblName);
            }

            if (!tblType.equalsIgnoreCase("MANAGED_TABLE")) {
                if (tblType.equalsIgnoreCase("EXTERNAL_TABLE") && tblFormat != null
                        && tblFormat.equalsIgnoreCase("pgdata")) {
                    LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                            + addPartitionDesc.getLevel() + ", msg=" + tblType + ":" + tblFormat
                            + " can not support alter partition");
                    throw new MetaException(tblType + ":" + tblFormat + " can not support alter partition");
                }

                if (externalPartition && tblType.equalsIgnoreCase("EXTERNAL_TABLE")
                        && (tblFormat == null || !tblFormat.equalsIgnoreCase("pgdata"))) {
                } else {
                    LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                            + addPartitionDesc.getLevel() + ", msg=" + tblType
                            + " can not support alter partition");

                    throw new MetaException(tblType + " can not support alter partition");
                }
            }

            if (!hasPriPart) {
                LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                        + addPartitionDesc.getLevel() + ", msg=" + "table " + dbName + ":" + tblName
                        + " is not pri-partitioned");

                throw new MetaException("table " + dbName + ":" + tblName + " is not pri-partitioned");
            }

            sql = "SELECT type_name from COLUMNS where tbl_id=" + tblID + " and column_name='"
                    + priPartKey.toLowerCase() + "'";
            isColFind = false;
            ResultSet colSet = stmt.executeQuery(sql);
            while (colSet.next()) {
                isColFind = true;
                priKeyType = colSet.getString(1);
                break;
            }
            colSet.close();

            if (!isColFind) {
                LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                        + addPartitionDesc.getLevel() + ", msg=" + "table "
                        + "can not find partition key information " + priPartKey);

                throw new MetaException("can not find partition key information " + priPartKey);
            }

            pti = new PrimitiveTypeInfo();
            pti.setTypeName(priKeyType);
            StringIO = PrimitiveObjectInspectorFactory
                    .getPrimitiveJavaObjectInspector(PrimitiveCategory.STRING);
            ValueIO = PrimitiveObjectInspectorFactory
                    .getPrimitiveWritableObjectInspector(pti.getPrimitiveCategory());
            converter1 = ObjectInspectorConverters.getConverter(StringIO, ValueIO);
            converter2 = ObjectInspectorConverters.getConverter(StringIO, ValueIO);

            if ((addPartitionDesc.getPartType().equalsIgnoreCase("RANGE_PARTITION")
                    && !priPartType.equalsIgnoreCase("range"))
                    || (addPartitionDesc.getPartType().equalsIgnoreCase("LIST_PARTITION")
                            && !priPartType.equalsIgnoreCase("list"))) {
                LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                        + addPartitionDesc.getLevel() + ", msg=" + "can not add  a "
                        + addPartitionDesc.getPartType() + " partition, but the pri-partition type is "
                        + priPartType);

                throw new MetaException("can not add  a " + addPartitionDesc.getPartType()
                        + " partition, but the pri-partition type is " + priPartType);
            }

            LinkedHashMap<String, List<String>> partSpaces = new LinkedHashMap<String, List<String>>();
            Set<String> subPartNameSet = new TreeSet<String>();

            sql = "SELECT level, part_name, part_values from PARTITIONS where" + " tbl_id=" + tblID;// + " order by level asc";

            ResultSet partSet = stmt.executeQuery(sql);
            int partLevel = 0;

            while (partSet.next()) {
                partLevel = partSet.getInt(1);

                if (partLevel == 0) {
                    String partName = partSet.getString(2);
                    List<String> valueList = new ArrayList<String>();
                    Array spaceArray = partSet.getArray(3);

                    ResultSet priValueSet = spaceArray.getResultSet();

                    while (priValueSet.next()) {
                        valueList.add(priValueSet.getString(2));
                    }

                    partSpaces.put(partName, valueList);
                } else if (partLevel == 1) {
                    String partName = partSet.getString(2);
                    subPartNameSet.add(partName);
                }
            }
            partSet.close();

            partToAdd = new ArrayList<String>();

            LinkedHashMap<String, List<String>> addPartSpaces = (LinkedHashMap<String, List<String>>) addPartitionDesc
                    .getParSpaces();

            Iterator<String> itr = addPartSpaces.keySet().iterator();

            while (itr.hasNext()) {
                String key = itr.next().toLowerCase();
                if (partSpaces.containsKey(key)) {
                    LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                            + addPartitionDesc.getLevel() + ", msg=" + "table : " + tblName
                            + " have already contain a pri parititon named: " + key);

                    throw new MetaException(
                            "table : " + tblName + " have already contain a pri parititon named: " + key);
                }
                partToAdd.add(key);
            }

            Iterator<List<String>> listItr = addPartSpaces.values().iterator();

            while (listItr.hasNext()) {
                Iterator<String> valueItr = listItr.next().iterator();
                if (valueItr.hasNext()) {
                    String value = valueItr.next();

                    if (converter1.convert(value) == null) {
                        LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                                + addPartitionDesc.getLevel() + ", msg=" + "value : " + value
                                + " should be type of " + priKeyType);

                        throw new MetaException("value : " + value + " should be type of " + priKeyType);
                    }

                    Iterator<List<String>> PartValuesItr = partSpaces.values().iterator();
                    while (PartValuesItr.hasNext()) {
                        if (PartValuesItr.next().contains(value)) {
                            LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                                    + addPartitionDesc.getLevel() + ", msg=" + "table : " + tblName
                                    + " have already contain a pri partition contain value: " + value);

                            throw new MetaException("table : " + tblName
                                    + " have already contain a pri partition contain value: " + value);
                        }
                    }
                }
            }

            ps = con.prepareStatement(
                    "INSERT INTO partitions(level, tbl_id, " + " part_name, part_values) values(?,?,?,?)");

            for (Map.Entry<String, List<String>> entry : addPartSpaces.entrySet()) {
                ps.setInt(1, 0);
                ps.setLong(2, tblID);

                Array spaceArray = con.createArrayOf("varchar", entry.getValue().toArray());
                ps.setArray(4, spaceArray);
                ps.setString(3, entry.getKey());

                ps.addBatch();
            }
            ps.executeBatch();

            if (!tblType.equalsIgnoreCase("EXTERNAL_TABLE")) {
                for (String partName : partToAdd) {
                    if (tblLocation == null || tblLocation.trim().isEmpty()) {
                        pathToMake.addAll(wh.getPriPartitionPaths(dbName, tblName, partName, subPartNameSet));
                    } else {
                        pathToMake.addAll(Warehouse.getPriPartitionPaths(new Path(tblLocation), partName,
                                subPartNameSet));
                    }
                }
            } else {
                for (String partName : partToAdd) {
                    pathToMake.addAll(
                            Warehouse.getPriPartitionPaths(new Path(tblLocation), partName, subPartNameSet));
                }
            }
        } else if (addPartitionDesc.getLevel() == 1) {
            sql = "SELECT tbl_id, tbl_type, sub_part_type, sub_part_key, tbl_format, tbl_location"
                    + " from TBLS where db_name='" + dbName.toLowerCase() + "' and tbl_name='"
                    + tblName.toLowerCase() + "'";

            tblSet = stmt.executeQuery(sql);
            isTblFind = false;

            while (tblSet.next()) {
                isTblFind = true;
                tblID = tblSet.getLong(1);
                tblType = tblSet.getString(2);
                subPartKey = tblSet.getString(4);
                subPartType = tblSet.getString(3);
                tblFormat = tblSet.getString(5);
                tblLocation = tblSet.getString(6);

                if (subPartType != null && !subPartType.isEmpty()) {
                    hasSubPart = true;
                }

                break;
            }

            tblSet.close();
            if (!isTblFind) {
                LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                        + addPartitionDesc.getLevel() + ", msg=" + "can not find table " + dbName + ":"
                        + tblName);

                throw new MetaException("can not find table " + dbName + ":" + tblName);
            }

            if (!tblType.equalsIgnoreCase("MANAGED_TABLE")) {
                if (tblType.equalsIgnoreCase("EXTERNAL_TABLE") && tblFormat != null
                        && tblFormat.equalsIgnoreCase("pgdata")) {
                    LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                            + addPartitionDesc.getLevel() + ", msg=" + tblType + ":" + tblFormat
                            + " can not support alter partition");
                    throw new MetaException(tblType + ":" + tblFormat + " can not support alter partition");
                }

                if (externalPartition && tblType.equalsIgnoreCase("EXTERNAL_TABLE")
                        && (tblFormat == null || !tblFormat.equalsIgnoreCase("pgdata"))) {
                } else {
                    LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                            + addPartitionDesc.getLevel() + ", msg=" + tblType
                            + " can not support alter partition");

                    throw new MetaException(tblType + " can not support alter partition");
                }
            }

            if (!hasSubPart) {
                LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                        + addPartitionDesc.getLevel() + ", msg=" + "table " + dbName + ":" + tblName
                        + " is not sun-partitioned");

                throw new MetaException("table " + dbName + ":" + tblName + " is not sun-partitioned");
            }

            sql = "SELECT type_name from COLUMNS where tbl_id=" + tblID + " and column_name='"
                    + subPartKey.toLowerCase() + "'";

            isColFind = false;
            ResultSet colSet = stmt.executeQuery(sql);
            while (colSet.next()) {
                isColFind = true;
                subKeyType = colSet.getString(1);
                break;
            }

            colSet.close();

            if (!isColFind) {
                LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                        + addPartitionDesc.getLevel() + ", msg=" + "can not find partition key information "
                        + priPartKey);

                throw new MetaException("can not find partition key information " + priPartKey);
            }

            pti = new PrimitiveTypeInfo();
            pti.setTypeName(subKeyType);
            StringIO = PrimitiveObjectInspectorFactory
                    .getPrimitiveJavaObjectInspector(PrimitiveCategory.STRING);
            ValueIO = PrimitiveObjectInspectorFactory
                    .getPrimitiveWritableObjectInspector(pti.getPrimitiveCategory());
            converter1 = ObjectInspectorConverters.getConverter(StringIO, ValueIO);
            converter2 = ObjectInspectorConverters.getConverter(StringIO, ValueIO);

            if ((addPartitionDesc.getPartType().equalsIgnoreCase("RANGE_PARTITION")
                    && !subPartType.equalsIgnoreCase("range"))
                    || (addPartitionDesc.getPartType().equalsIgnoreCase("LIST_PARTITION")
                            && !subPartType.equalsIgnoreCase("list"))) {
                LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                        + addPartitionDesc.getLevel() + ", msg=" + "you can not add  a "
                        + addPartitionDesc.getPartType() + " partition, but the sub-partition type is "
                        + subPartType);

                throw new MetaException("you can not add  a " + addPartitionDesc.getPartType()
                        + " partition, but the sub-partition type is " + subPartType);
            }

            LinkedHashMap<String, List<String>> partSpaces = new LinkedHashMap<String, List<String>>();
            Set<String> partNameSet = new TreeSet<String>();

            sql = "SELECT level,  part_name, part_values from PARTITIONS where" + " tbl_id=" + tblID;// + " order by level asc";

            ResultSet partSet = stmt.executeQuery(sql);
            int partLevel = 0;

            while (partSet.next()) {
                partLevel = partSet.getInt(1);

                if (partLevel == 1) {
                    String partName = partSet.getString(2);
                    List<String> valueList = new ArrayList<String>();
                    Array spaceArray = partSet.getArray(3);

                    ResultSet priValueSet = spaceArray.getResultSet();

                    while (priValueSet.next()) {
                        valueList.add(priValueSet.getString(2));
                    }
                    partSpaces.put(partName, valueList);
                } else if (partLevel == 0) {
                    String partName = partSet.getString(2);
                    partNameSet.add(partName);
                }
            }

            partToAdd = new ArrayList<String>();

            LinkedHashMap<String, List<String>> addPartSpaces = (LinkedHashMap<String, List<String>>) addPartitionDesc
                    .getParSpaces();

            Iterator<String> itr = addPartSpaces.keySet().iterator();

            while (itr.hasNext()) {
                String key = itr.next().toLowerCase();
                if (partSpaces.containsKey(key)) {
                    LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                            + addPartitionDesc.getLevel() + ", msg=" + "table : " + tblName
                            + " have already contain a sub parititon named: " + key);

                    throw new MetaException(
                            "table : " + tblName + " have already contain a sub parititon named: " + key);
                }

                if (key.equalsIgnoreCase("default")) {
                    LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                            + addPartitionDesc.getLevel() + ", msg="
                            + "use : 'alter table tblname add default subpartition' to add default subpartition!");

                    throw new MetaException(
                            "use : 'alter table tblname add default subpartition' to add default subpartition!");
                }
                partToAdd.add(key);
            }

            Iterator<List<String>> listItr = addPartSpaces.values().iterator();

            while (listItr.hasNext()) {
                Iterator<String> valueItr = listItr.next().iterator();
                if (valueItr.hasNext()) {
                    String value = valueItr.next();

                    if (converter1.convert(value) == null) {
                        LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                                + addPartitionDesc.getLevel() + ", msg=" + "value : " + value
                                + " should be type of " + priKeyType);

                        throw new MetaException("value : " + value + " should be type of " + priKeyType);
                    }

                    Iterator<List<String>> PartValuesItr = partSpaces.values().iterator();
                    while (PartValuesItr.hasNext()) {
                        if (PartValuesItr.next().contains(value)) {
                            LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                                    + addPartitionDesc.getLevel() + ", msg=" + "table : " + tblName
                                    + " have already contain a sub partition contain value: " + value);

                            throw new MetaException("table : " + tblName
                                    + " have already contain a sub partition contain value: " + value);
                        }
                    }
                }
            }

            ps = con.prepareStatement(
                    "INSERT INTO partitions(level, tbl_id, " + " part_name, part_values) values(?,?,?,?)");

            for (Map.Entry<String, List<String>> entry : addPartSpaces.entrySet()) {
                ps.setInt(1, 1);
                ps.setLong(2, tblID);

                Array spaceArray = con.createArrayOf("varchar", entry.getValue().toArray());
                ps.setArray(4, spaceArray);
                ps.setString(3, entry.getKey());

                ps.addBatch();
            }
            ps.executeBatch();

            if (!tblType.equalsIgnoreCase("EXTERNAL_TABLE")) {
                for (String partName : partToAdd) {
                    if (tblLocation == null || tblLocation.trim().isEmpty()) {
                        pathToMake.addAll(wh.getSubPartitionPaths(dbName, tblName, partNameSet, partName));
                    } else {
                        pathToMake.addAll(
                                Warehouse.getSubPartitionPaths(new Path(tblLocation), partNameSet, partName));
                    }
                }
            } else {
                for (String partName : partToAdd) {
                    pathToMake.addAll(
                            Warehouse.getSubPartitionPaths(new Path(tblLocation), partNameSet, partName));
                }
            }
        }

        con.commit();
        success = true;
    } catch (SQLException ex) {
        ex.printStackTrace();
        LOG.error("add partition error, db=" + dbName + ", tbl=" + tblName + ", level="
                + addPartitionDesc.getLevel() + ", msg=" + ex.getMessage());

        throw new MetaException(ex.getMessage());
    } finally {
        if (!success) {
            try {
                con.rollback();
            } catch (SQLException e) {
            }

            if (isPathMaked) {
                for (Path path : pathToMake) {
                    wh.deleteDir(path, false);
                }
            }
        }

        closeStatement(ps);
        closeConnection(con);
    }

    if (success) {
        boolean mkDirOK = false;
        List<Path> createdPath = new ArrayList<Path>();
        try {
            for (Path path : pathToMake) {
                mkDirOK = wh.mkdirs(path);
                if (!mkDirOK) {
                    break;
                }

                createdPath.add(path);
            }
        } catch (Exception x) {
            mkDirOK = false;
        }

        if (!mkDirOK) {
            dropPartitionMeta(dbName, tblID, addPartitionDesc);
            if (!createdPath.isEmpty()) {
                for (Path path : createdPath) {
                    wh.deleteDir(path, true);
                }
            }

            throw new MetaException("can not create hdfs path, add partition failed");
        }

    }
}