#318

Build # #318

Build Type

push

Committed by

Commit Message

Feature/upgrade springboot (#268)

* update springboot to 2.1.18

* update springboot to 2.2.13

* Upgrade to srping boot 2.7.11

* Update changelog

* Update changelog

* fix version

Run Details

3 of 3 new or added lines in 2 files covered. (100.0%)

132 of 3058 relevant lines covered (4.32%)

0.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/waggle-dance-core/src/main/java/com/hotels/bdp/waggledance/mapping/model/DatabaseMappingImpl.java

/**
 * Copyright (C) 2016-2023 Expedia, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.hotels.bdp.waggledance.mapping.model;

import java.io.IOException;
import java.util.List;

import org.apache.hadoop.hive.metastore.MetaStoreFilterHook;
import org.apache.hadoop.hive.metastore.api.AddDynamicPartitions;
import org.apache.hadoop.hive.metastore.api.AddPartitionsRequest;
import org.apache.hadoop.hive.metastore.api.AddPartitionsResult;
import org.apache.hadoop.hive.metastore.api.AlreadyExistsException;
import org.apache.hadoop.hive.metastore.api.CacheFileMetadataRequest;
import org.apache.hadoop.hive.metastore.api.ColumnStatistics;
import org.apache.hadoop.hive.metastore.api.CompactionRequest;
import org.apache.hadoop.hive.metastore.api.Database;
import org.apache.hadoop.hive.metastore.api.DropConstraintRequest;
import org.apache.hadoop.hive.metastore.api.DropPartitionsRequest;
import org.apache.hadoop.hive.metastore.api.DropPartitionsResult;
import org.apache.hadoop.hive.metastore.api.FireEventRequest;
import org.apache.hadoop.hive.metastore.api.ForeignKeysRequest;
import org.apache.hadoop.hive.metastore.api.ForeignKeysResponse;
import org.apache.hadoop.hive.metastore.api.Function;
import org.apache.hadoop.hive.metastore.api.GetTableRequest;
import org.apache.hadoop.hive.metastore.api.GetTableResult;
import org.apache.hadoop.hive.metastore.api.GetTablesRequest;
import org.apache.hadoop.hive.metastore.api.GetTablesResult;
import org.apache.hadoop.hive.metastore.api.GrantRevokePrivilegeRequest;
import org.apache.hadoop.hive.metastore.api.HiveObjectPrivilege;
import org.apache.hadoop.hive.metastore.api.HiveObjectRef;
import org.apache.hadoop.hive.metastore.api.HiveObjectType;
import org.apache.hadoop.hive.metastore.api.Index;
import org.apache.hadoop.hive.metastore.api.InvalidObjectException;
import org.apache.hadoop.hive.metastore.api.LockComponent;
import org.apache.hadoop.hive.metastore.api.LockRequest;
import org.apache.hadoop.hive.metastore.api.MetaException;
import org.apache.hadoop.hive.metastore.api.Partition;
import org.apache.hadoop.hive.metastore.api.PartitionSpec;
import org.apache.hadoop.hive.metastore.api.PartitionValuesRequest;
import org.apache.hadoop.hive.metastore.api.PartitionsByExprRequest;
import org.apache.hadoop.hive.metastore.api.PartitionsByExprResult;
import org.apache.hadoop.hive.metastore.api.PartitionsStatsRequest;
import org.apache.hadoop.hive.metastore.api.PrimaryKeysRequest;
import org.apache.hadoop.hive.metastore.api.PrimaryKeysResponse;
import org.apache.hadoop.hive.metastore.api.PrivilegeBag;
import org.apache.hadoop.hive.metastore.api.SQLForeignKey;
import org.apache.hadoop.hive.metastore.api.SQLPrimaryKey;
import org.apache.hadoop.hive.metastore.api.SetPartitionsStatsRequest;
import org.apache.hadoop.hive.metastore.api.Table;
import org.apache.hadoop.hive.metastore.api.TableMeta;
import org.apache.hadoop.hive.metastore.api.TableStatsRequest;
import org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface;
import org.apache.thrift.TException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.hotels.bdp.waggledance.api.WaggleDanceException;

public class DatabaseMappingImpl implements DatabaseMapping {

  private final static Logger log = LoggerFactory.getLogger(DatabaseMappingImpl.class);

  private final MetaStoreMapping metaStoreMapping;
  private final QueryMapping queryMapping;

  public DatabaseMappingImpl(MetaStoreMapping metaStoreMapping, QueryMapping queryMapping) {
    this.metaStoreMapping = metaStoreMapping;
    this.queryMapping = queryMapping;
  }

  @Override
  public MetaStoreFilterHook getMetastoreFilter() {
    return metaStoreMapping.getMetastoreFilter();
  }

  @Override
  public Table transformOutboundTable(Table table) {
    String originalDatabaseName = table.getDbName();
    String databaseName = metaStoreMapping.transformOutboundDatabaseName(originalDatabaseName);
    table.setDbName(databaseName);
    if (databaseName.equalsIgnoreCase(originalDatabaseName)) {
      // Skip all the view parsing if nothing is going to change, the parsing is not without problems and we can't catch
      // all use cases here. For instance Presto creates views that are stored in these fields and this is stored
      // differently than Hive. There might be others.
      return table;
    }
    if (table.isSetViewExpandedText()) {
      try {
        log.debug("Transforming ViewExpandedText: {}", table.getViewExpandedText());
        table
            .setViewExpandedText(
                queryMapping.transformOutboundDatabaseName(metaStoreMapping, table.getViewExpandedText()));
      } catch (WaggleDanceException e) {
        log.debug("Error while transforming databaseName in ViewExpandedText, keeping original", e);
      }
    }
    if (table.isSetViewOriginalText()) {
      try {
        log.debug("Transforming ViewOriginalText: {}", table.getViewOriginalText());
        table
            .setViewOriginalText(
                queryMapping.transformOutboundDatabaseName(metaStoreMapping, table.getViewOriginalText()));
      } catch (WaggleDanceException e) {
        // We are hitting a bug in hive (https://issues.apache.org/jira/browse/HIVE-19896) that prevents the
        // ViewOriginalText to be parsed, if we leave the ViewOriginalText we'll have the wrong database names in it so
        // we set the ViewExpandedText to at least return a "correct" view query string. Hard to see what is the usage
        // and impact of this.
        log.debug("Error while transforming databaseName in ViewOriginalText, using ViewExpandedText if available", e);
        if (table.isSetViewExpandedText()) {
          table.setViewOriginalText(table.getViewExpandedText());
        }
      }
    }
    return table;
  }

  @Override
  public Partition transformOutboundPartition(Partition partition) {
    partition.setDbName(metaStoreMapping.transformOutboundDatabaseName(partition.getDbName()));
    return partition;
  }

  @Override
  public Index transformOutboundIndex(Index index) {
    index.setDbName(metaStoreMapping.transformOutboundDatabaseName(index.getDbName()));
    return index;
  }

  @Override
  public Table transformInboundTable(Table table) {
    table.setDbName(metaStoreMapping.transformInboundDatabaseName(table.getDbName()));
    return table;
  }

  @Override
  public Partition transformInboundPartition(Partition partition) {
    partition.setDbName(metaStoreMapping.transformInboundDatabaseName(partition.getDbName()));
    return partition;
  }

  @Override
  public Index transformInboundIndex(Index index) {
    index.setDbName(metaStoreMapping.transformInboundDatabaseName(index.getDbName()));
    return index;
  }

  @Override
  public Function transformOutboundFunction(Function function) {
    function.setDbName(metaStoreMapping.transformOutboundDatabaseName(function.getDbName()));
    return function;
  }

  @Override
  public HiveObjectRef transformInboundHiveObjectRef(HiveObjectRef obj) {
    obj.setDbName(metaStoreMapping.transformInboundDatabaseName(obj.getDbName()));
    if (obj.getObjectName()!=null && obj.getObjectType() == HiveObjectType.DATABASE) {
      obj.setObjectName(metaStoreMapping.transformInboundDatabaseName(obj.getObjectName()));
    }
    return obj;
  }

  @Override
  public HiveObjectRef transformOutboundHiveObjectRef(HiveObjectRef obj) {
    obj.setDbName(metaStoreMapping.transformOutboundDatabaseName(obj.getDbName()));
    if (obj.getObjectType() == HiveObjectType.DATABASE) {
      obj.setObjectName(metaStoreMapping.transformOutboundDatabaseName(obj.getObjectName()));
    }
    return obj;
  }

  @Override
  public PartitionSpec transformOutboundPartitionSpec(PartitionSpec partitionSpec) {
    partitionSpec.setDbName(metaStoreMapping.transformOutboundDatabaseName(partitionSpec.getDbName()));
    return partitionSpec;
  }

  @Override
  public PartitionsStatsRequest transformInboundPartitionsStatsRequest(PartitionsStatsRequest request) {
    request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));
    return request;
  }

  @Override
  public TableStatsRequest transformInboundTableStatsRequest(TableStatsRequest request) {
    request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));
    return request;
  }

  @Override
  public PartitionsByExprRequest transformInboundPartitionsByExprRequest(PartitionsByExprRequest req) {
    req.setDbName(metaStoreMapping.transformInboundDatabaseName(req.getDbName()));
    return req;
  }

  @Override
  public PartitionsByExprResult transformOutboundPartitionsByExprResult(PartitionsByExprResult result) {
    result.setPartitions(transformOutboundPartitions(result.getPartitions()));
    return result;
  }

  @Override
  public Iface getClient() {
    return metaStoreMapping.getClient();
  }

  @Override
  public String transformOutboundDatabaseName(String databaseName) {
    return metaStoreMapping.transformOutboundDatabaseName(databaseName);
  }

  @Override
  public List<String> transformOutboundDatabaseNameMultiple(String databaseName) {
    return metaStoreMapping.transformOutboundDatabaseNameMultiple(databaseName);
  }

  @Override
  public Database transformOutboundDatabase(Database database) {
    return metaStoreMapping.transformOutboundDatabase(database);
  }

  @Override
  public String transformInboundDatabaseName(String databaseName) {
    return metaStoreMapping.transformInboundDatabaseName(databaseName);
  }

  @Override
  public String getDatabasePrefix() {
    return metaStoreMapping.getDatabasePrefix();
  }

  @Override
  public String getMetastoreMappingName() {
    return metaStoreMapping.getMetastoreMappingName();
  }

  @Override
  public CacheFileMetadataRequest transformInboundCacheFileMetadataRequest(CacheFileMetadataRequest req) {
    req.setDbName(metaStoreMapping.transformInboundDatabaseName(req.getDbName()));
    return req;
  }

  @Override
  public FireEventRequest transformInboundFireEventRequest(FireEventRequest rqst) {
    rqst.setDbName(metaStoreMapping.transformInboundDatabaseName(rqst.getDbName()));
    return rqst;
  }

  @Override
  public ForeignKeysRequest transformInboundForeignKeysRequest(ForeignKeysRequest request) {
    String parentDbName = request.getParent_db_name() == null ? null
        : metaStoreMapping.transformInboundDatabaseName(request.getParent_db_name());
    String foreignDbName = request.getForeign_db_name() == null ? null
        : metaStoreMapping.transformInboundDatabaseName(request.getForeign_db_name());

    request.setParent_db_name(parentDbName);
    request.setForeign_db_name(foreignDbName);
    return request;
  }

  @Override
  public ForeignKeysResponse transformOutboundForeignKeysResponse(ForeignKeysResponse response) {
    for (SQLForeignKey key : response.getForeignKeys()) {
      key.setPktable_db(metaStoreMapping.transformOutboundDatabaseName(key.getPktable_db()));
      key.setFktable_db(metaStoreMapping.transformOutboundDatabaseName(key.getFktable_db()));
    }
    return response;
  }

  @Override
  public PrimaryKeysRequest transformInboundPrimaryKeysRequest(PrimaryKeysRequest request) {
    request.setDb_name(metaStoreMapping.transformInboundDatabaseName(request.getDb_name()));
    return request;
  }

  @Override
  public PrimaryKeysResponse transformOutboundPrimaryKeysResponse(PrimaryKeysResponse response) {
    for (SQLPrimaryKey key : response.getPrimaryKeys()) {
      key.setTable_db(metaStoreMapping.transformOutboundDatabaseName(key.getTable_db()));
    }
    return response;
  }

  @Override
  public TableMeta transformOutboundTableMeta(TableMeta tableMeta) {
    tableMeta.setDbName(metaStoreMapping.transformOutboundDatabaseName(tableMeta.getDbName()));
    return tableMeta;
  }

  @Override
  public AddDynamicPartitions transformInboundAddDynamicPartitions(AddDynamicPartitions request) {
    request.setDbname(metaStoreMapping.transformInboundDatabaseName(request.getDbname()));
    return request;
  }

  @Override
  public void close() throws IOException {
    metaStoreMapping.close();
  }

  @Override
  public boolean isAvailable() {
    return metaStoreMapping.isAvailable();
  }

  @Override
  public MetaStoreMapping checkWritePermissions(String databaseName) throws IllegalArgumentException {
    return metaStoreMapping.checkWritePermissions(transformInboundDatabaseName(databaseName));
  }

  @Override
  public DropConstraintRequest transformInboundDropConstraintRequest(DropConstraintRequest request) {
    request.setDbname(metaStoreMapping.transformInboundDatabaseName(request.getDbname()));
    return request;
  }

  @Override
  public AddPartitionsRequest transformInboundAddPartitionsRequest(AddPartitionsRequest request) {
    request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));
    request.setParts(transformInboundPartitions(request.getParts()));
    return request;
  }

  @Override
  public AddPartitionsResult transformOutboundAddPartitionsResult(AddPartitionsResult result) {
    result.setPartitions(transformOutboundPartitions(result.getPartitions()));
    return result;
  }

  @Override
  public DropPartitionsRequest transformInboundDropPartitionRequest(DropPartitionsRequest request) {
    request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));
    return request;
  }

  @Override
  public DropPartitionsResult transformOutboundDropPartitionsResult(DropPartitionsResult result) {
    result.setPartitions(transformOutboundPartitions(result.getPartitions()));
    return result;
  }

  @Override
  public List<Partition> transformOutboundPartitions(List<Partition> partitions) {
    for (Partition partition : partitions) {
      transformOutboundPartition(partition);
    }
    return partitions;
  }

  @Override
  public List<PartitionSpec> transformOutboundPartitionSpecs(List<PartitionSpec> partitionSpecs) {
    for (PartitionSpec partitionSpec : partitionSpecs) {
      transformOutboundPartitionSpec(partitionSpec);
    }
    return partitionSpecs;
  }

  @Override
  public List<Partition> transformInboundPartitions(List<Partition> partitions) {
    for (Partition partition : partitions) {
      transformInboundPartition(partition);
    }
    return partitions;
  }

  @Override
  public List<Index> transformOutboundIndexes(List<Index> indexes) {
    for (Index index : indexes) {
      transformOutboundIndex(index);
    }
    return indexes;
  }

  @Override
  public ColumnStatistics transformInboundColumnStatistics(ColumnStatistics columnStatistics) {
    columnStatistics
        .getStatsDesc()
        .setDbName(metaStoreMapping.transformInboundDatabaseName(columnStatistics.getStatsDesc().getDbName()));
    return columnStatistics;
  }

  @Override
  public ColumnStatistics transformOutboundColumnStatistics(ColumnStatistics columnStatistics) {
    columnStatistics
        .getStatsDesc()
        .setDbName(metaStoreMapping.transformOutboundDatabaseName(columnStatistics.getStatsDesc().getDbName()));
    return columnStatistics;
  }

  @Override
  public SetPartitionsStatsRequest transformInboundSetPartitionStatsRequest(SetPartitionsStatsRequest request) {
    if (request.isSetColStats()) {
      for (ColumnStatistics stats : request.getColStats()) {
        transformInboundColumnStatistics(stats);
      }
    }
    return request;
  }

  @Override
  public Function transformInboundFunction(Function function) {
    function.setDbName(metaStoreMapping.transformInboundDatabaseName(function.getDbName()));
    return function;
  }

  @Override
  public List<HiveObjectPrivilege> transformOutboundHiveObjectPrivileges(List<HiveObjectPrivilege> privileges) {
    for (HiveObjectPrivilege privilege : privileges) {
      privilege.setHiveObject(transformOutboundHiveObjectRef(privilege.getHiveObject()));
    }
    return privileges;
  }

  @Override
  public PrivilegeBag transformInboundPrivilegeBag(PrivilegeBag privilegeBag) {
    if (privilegeBag.isSetPrivileges()) {
      for (HiveObjectPrivilege privilege : privilegeBag.getPrivileges()) {
        privilege.setHiveObject(transformInboundHiveObjectRef(privilege.getHiveObject()));
      }
    }
    return privilegeBag;
  }

  @Override
  public GrantRevokePrivilegeRequest transformInboundGrantRevokePrivilegesRequest(GrantRevokePrivilegeRequest request) {
    if (request.isSetPrivileges()) {
      request.setPrivileges(transformInboundPrivilegeBag(request.getPrivileges()));
    }
    return request;
  }

  @Override
  public LockRequest transformInboundLockRequest(LockRequest request) {
    if (request.isSetComponent()) {
      for (LockComponent component : request.getComponent()) {
        component.setDbname(metaStoreMapping.transformInboundDatabaseName(component.getDbname()));
      }
    }
    return request;
  }

  @Override
  public CompactionRequest transformInboundCompactionRequest(CompactionRequest request) {
    request.setDbname(metaStoreMapping.transformInboundDatabaseName(request.getDbname()));
    return request;
  }

  @Override
  public void createDatabase(Database database)
    throws AlreadyExistsException, InvalidObjectException, MetaException, TException {
    metaStoreMapping.createDatabase(database);
  }

  @Override
  public Database transformInboundDatabase(Database database) {
    database.setName(metaStoreMapping.transformInboundDatabaseName(database.getName()));
    return database;
  }

  @Override
  public List<PartitionSpec> transformInboundPartitionSpecs(List<PartitionSpec> partitionSpecs) {
    for (PartitionSpec partitionSpec : partitionSpecs) {
      partitionSpec.setDbName(metaStoreMapping.transformInboundDatabaseName(partitionSpec.getDbName()));
    }
    return partitionSpecs;
  }

  @Override
  public GetTableRequest transformInboundGetTableRequest(GetTableRequest request) {
    request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));
    return request;
  }

  @Override
  public GetTableResult transformOutboundGetTableResult(GetTableResult result) {
    transformOutboundTable(result.getTable());
    return result;
  }

  @Override
  public GetTablesRequest transformInboundGetTablesRequest(GetTablesRequest request) {
    request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));
    return request;
  }

  @Override
  public GetTablesResult transformOutboundGetTablesResult(GetTablesResult result) {
    for (Table table : result.getTables()) {
      transformOutboundTable(table);
    }
    return result;
  }

  @Override
  public PartitionValuesRequest transformInboundPartitionValuesRequest(PartitionValuesRequest request) {
    request.setDbName(transformInboundDatabaseName(request.getDbName()));
    return request;
  }

  @Override
  public long getLatency() {
    return metaStoreMapping.getLatency();
  }

}

1	/**
2	* Copyright (C) 2016-2023 Expedia, Inc.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package com.hotels.bdp.waggledance.mapping.model;
17
18	import java.io.IOException;
19	import java.util.List;
20
21	import org.apache.hadoop.hive.metastore.MetaStoreFilterHook;
22	import org.apache.hadoop.hive.metastore.api.AddDynamicPartitions;
23	import org.apache.hadoop.hive.metastore.api.AddPartitionsRequest;
24	import org.apache.hadoop.hive.metastore.api.AddPartitionsResult;
25	import org.apache.hadoop.hive.metastore.api.AlreadyExistsException;
26	import org.apache.hadoop.hive.metastore.api.CacheFileMetadataRequest;
27	import org.apache.hadoop.hive.metastore.api.ColumnStatistics;
28	import org.apache.hadoop.hive.metastore.api.CompactionRequest;
29	import org.apache.hadoop.hive.metastore.api.Database;
30	import org.apache.hadoop.hive.metastore.api.DropConstraintRequest;
31	import org.apache.hadoop.hive.metastore.api.DropPartitionsRequest;
32	import org.apache.hadoop.hive.metastore.api.DropPartitionsResult;
33	import org.apache.hadoop.hive.metastore.api.FireEventRequest;
34	import org.apache.hadoop.hive.metastore.api.ForeignKeysRequest;
35	import org.apache.hadoop.hive.metastore.api.ForeignKeysResponse;
36	import org.apache.hadoop.hive.metastore.api.Function;
37	import org.apache.hadoop.hive.metastore.api.GetTableRequest;
38	import org.apache.hadoop.hive.metastore.api.GetTableResult;
39	import org.apache.hadoop.hive.metastore.api.GetTablesRequest;
40	import org.apache.hadoop.hive.metastore.api.GetTablesResult;
41	import org.apache.hadoop.hive.metastore.api.GrantRevokePrivilegeRequest;
42	import org.apache.hadoop.hive.metastore.api.HiveObjectPrivilege;
43	import org.apache.hadoop.hive.metastore.api.HiveObjectRef;
44	import org.apache.hadoop.hive.metastore.api.HiveObjectType;
45	import org.apache.hadoop.hive.metastore.api.Index;
46	import org.apache.hadoop.hive.metastore.api.InvalidObjectException;
47	import org.apache.hadoop.hive.metastore.api.LockComponent;
48	import org.apache.hadoop.hive.metastore.api.LockRequest;
49	import org.apache.hadoop.hive.metastore.api.MetaException;
50	import org.apache.hadoop.hive.metastore.api.Partition;
51	import org.apache.hadoop.hive.metastore.api.PartitionSpec;
52	import org.apache.hadoop.hive.metastore.api.PartitionValuesRequest;
53	import org.apache.hadoop.hive.metastore.api.PartitionsByExprRequest;
54	import org.apache.hadoop.hive.metastore.api.PartitionsByExprResult;
55	import org.apache.hadoop.hive.metastore.api.PartitionsStatsRequest;
56	import org.apache.hadoop.hive.metastore.api.PrimaryKeysRequest;
57	import org.apache.hadoop.hive.metastore.api.PrimaryKeysResponse;
58	import org.apache.hadoop.hive.metastore.api.PrivilegeBag;
59	import org.apache.hadoop.hive.metastore.api.SQLForeignKey;
60	import org.apache.hadoop.hive.metastore.api.SQLPrimaryKey;
61	import org.apache.hadoop.hive.metastore.api.SetPartitionsStatsRequest;
62	import org.apache.hadoop.hive.metastore.api.Table;
63	import org.apache.hadoop.hive.metastore.api.TableMeta;
64	import org.apache.hadoop.hive.metastore.api.TableStatsRequest;
65	import org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface;
66	import org.apache.thrift.TException;
67	import org.slf4j.Logger;
68	import org.slf4j.LoggerFactory;
69
70	import com.hotels.bdp.waggledance.api.WaggleDanceException;
71
72	public class DatabaseMappingImpl implements DatabaseMapping {
73
74	private final static Logger log = LoggerFactory.getLogger(DatabaseMappingImpl.class);	×
75
76	private final MetaStoreMapping metaStoreMapping;
77	private final QueryMapping queryMapping;
78
79	public DatabaseMappingImpl(MetaStoreMapping metaStoreMapping, QueryMapping queryMapping) {	×
80	this.metaStoreMapping = metaStoreMapping;	×
81	this.queryMapping = queryMapping;	×
82	}	×
83
84	@Override
85	public MetaStoreFilterHook getMetastoreFilter() {
86	return metaStoreMapping.getMetastoreFilter();	×
87	}
88
89	@Override
90	public Table transformOutboundTable(Table table) {
91	String originalDatabaseName = table.getDbName();	×
92	String databaseName = metaStoreMapping.transformOutboundDatabaseName(originalDatabaseName);	×
93	table.setDbName(databaseName);	×
94	if (databaseName.equalsIgnoreCase(originalDatabaseName)) {	×
95	// Skip all the view parsing if nothing is going to change, the parsing is not without problems and we can't catch
96	// all use cases here. For instance Presto creates views that are stored in these fields and this is stored
97	// differently than Hive. There might be others.
98	return table;	×
99	}
100	if (table.isSetViewExpandedText()) {	×
101	try {
102	log.debug("Transforming ViewExpandedText: {}", table.getViewExpandedText());	×
103	table	×
104	.setViewExpandedText(	×
105	queryMapping.transformOutboundDatabaseName(metaStoreMapping, table.getViewExpandedText()));	×
106	} catch (WaggleDanceException e) {	×
107	log.debug("Error while transforming databaseName in ViewExpandedText, keeping original", e);	×
108	}
109	}
110	if (table.isSetViewOriginalText()) {	×
111	try {
112	log.debug("Transforming ViewOriginalText: {}", table.getViewOriginalText());	×
113	table	×
114	.setViewOriginalText(	×
115	queryMapping.transformOutboundDatabaseName(metaStoreMapping, table.getViewOriginalText()));	×
116	} catch (WaggleDanceException e) {	×
117	// We are hitting a bug in hive (https://issues.apache.org/jira/browse/HIVE-19896) that prevents the
118	// ViewOriginalText to be parsed, if we leave the ViewOriginalText we'll have the wrong database names in it so
119	// we set the ViewExpandedText to at least return a "correct" view query string. Hard to see what is the usage
120	// and impact of this.
121	log.debug("Error while transforming databaseName in ViewOriginalText, using ViewExpandedText if available", e);	×
122	if (table.isSetViewExpandedText()) {	×
123	table.setViewOriginalText(table.getViewExpandedText());	×
124	}
125	}
126	}
127	return table;	×
128	}
129
130	@Override
131	public Partition transformOutboundPartition(Partition partition) {
132	partition.setDbName(metaStoreMapping.transformOutboundDatabaseName(partition.getDbName()));	×
133	return partition;	×
134	}
135
136	@Override
137	public Index transformOutboundIndex(Index index) {
138	index.setDbName(metaStoreMapping.transformOutboundDatabaseName(index.getDbName()));	×
139	return index;	×
140	}
141
142	@Override
143	public Table transformInboundTable(Table table) {
144	table.setDbName(metaStoreMapping.transformInboundDatabaseName(table.getDbName()));	×
145	return table;	×
146	}
147
148	@Override
149	public Partition transformInboundPartition(Partition partition) {
150	partition.setDbName(metaStoreMapping.transformInboundDatabaseName(partition.getDbName()));	×
151	return partition;	×
152	}
153
154	@Override
155	public Index transformInboundIndex(Index index) {
156	index.setDbName(metaStoreMapping.transformInboundDatabaseName(index.getDbName()));	×
157	return index;	×
158	}
159
160	@Override
161	public Function transformOutboundFunction(Function function) {
162	function.setDbName(metaStoreMapping.transformOutboundDatabaseName(function.getDbName()));	×
163	return function;	×
164	}
165
166	@Override
167	public HiveObjectRef transformInboundHiveObjectRef(HiveObjectRef obj) {
168	obj.setDbName(metaStoreMapping.transformInboundDatabaseName(obj.getDbName()));	×
169	if (obj.getObjectName()!=null && obj.getObjectType() == HiveObjectType.DATABASE) {	×
170	obj.setObjectName(metaStoreMapping.transformInboundDatabaseName(obj.getObjectName()));	×
171	}
172	return obj;	×
173	}
174
175	@Override
176	public HiveObjectRef transformOutboundHiveObjectRef(HiveObjectRef obj) {
177	obj.setDbName(metaStoreMapping.transformOutboundDatabaseName(obj.getDbName()));	×
178	if (obj.getObjectType() == HiveObjectType.DATABASE) {	×
179	obj.setObjectName(metaStoreMapping.transformOutboundDatabaseName(obj.getObjectName()));	×
180	}
181	return obj;	×
182	}
183
184	@Override
185	public PartitionSpec transformOutboundPartitionSpec(PartitionSpec partitionSpec) {
186	partitionSpec.setDbName(metaStoreMapping.transformOutboundDatabaseName(partitionSpec.getDbName()));	×
187	return partitionSpec;	×
188	}
189
190	@Override
191	public PartitionsStatsRequest transformInboundPartitionsStatsRequest(PartitionsStatsRequest request) {
192	request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));	×
193	return request;	×
194	}
195
196	@Override
197	public TableStatsRequest transformInboundTableStatsRequest(TableStatsRequest request) {
198	request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));	×
199	return request;	×
200	}
201
202	@Override
203	public PartitionsByExprRequest transformInboundPartitionsByExprRequest(PartitionsByExprRequest req) {
204	req.setDbName(metaStoreMapping.transformInboundDatabaseName(req.getDbName()));	×
205	return req;	×
206	}
207
208	@Override
209	public PartitionsByExprResult transformOutboundPartitionsByExprResult(PartitionsByExprResult result) {
210	result.setPartitions(transformOutboundPartitions(result.getPartitions()));	×
211	return result;	×
212	}
213
214	@Override
215	public Iface getClient() {
216	return metaStoreMapping.getClient();	×
217	}
218
219	@Override
220	public String transformOutboundDatabaseName(String databaseName) {
221	return metaStoreMapping.transformOutboundDatabaseName(databaseName);	×
222	}
223
224	@Override
225	public List<String> transformOutboundDatabaseNameMultiple(String databaseName) {
226	return metaStoreMapping.transformOutboundDatabaseNameMultiple(databaseName);	×
227	}
228
229	@Override
230	public Database transformOutboundDatabase(Database database) {
231	return metaStoreMapping.transformOutboundDatabase(database);	×
232	}
233
234	@Override
235	public String transformInboundDatabaseName(String databaseName) {
236	return metaStoreMapping.transformInboundDatabaseName(databaseName);	×
237	}
238
239	@Override
240	public String getDatabasePrefix() {
241	return metaStoreMapping.getDatabasePrefix();	×
242	}
243
244	@Override
245	public String getMetastoreMappingName() {
246	return metaStoreMapping.getMetastoreMappingName();	×
247	}
248
249	@Override
250	public CacheFileMetadataRequest transformInboundCacheFileMetadataRequest(CacheFileMetadataRequest req) {
251	req.setDbName(metaStoreMapping.transformInboundDatabaseName(req.getDbName()));	×
252	return req;	×
253	}
254
255	@Override
256	public FireEventRequest transformInboundFireEventRequest(FireEventRequest rqst) {
257	rqst.setDbName(metaStoreMapping.transformInboundDatabaseName(rqst.getDbName()));	×
258	return rqst;	×
259	}
260
261	@Override
262	public ForeignKeysRequest transformInboundForeignKeysRequest(ForeignKeysRequest request) {
263	String parentDbName = request.getParent_db_name() == null ? null	×
264	: metaStoreMapping.transformInboundDatabaseName(request.getParent_db_name());	×
265	String foreignDbName = request.getForeign_db_name() == null ? null	×
266	: metaStoreMapping.transformInboundDatabaseName(request.getForeign_db_name());	×
267
268	request.setParent_db_name(parentDbName);	×
269	request.setForeign_db_name(foreignDbName);	×
270	return request;	×
271	}
272
273	@Override
274	public ForeignKeysResponse transformOutboundForeignKeysResponse(ForeignKeysResponse response) {
275	for (SQLForeignKey key : response.getForeignKeys()) {	×
276	key.setPktable_db(metaStoreMapping.transformOutboundDatabaseName(key.getPktable_db()));	×
277	key.setFktable_db(metaStoreMapping.transformOutboundDatabaseName(key.getFktable_db()));	×
278	}
279	return response;	×
280	}
281
282	@Override
283	public PrimaryKeysRequest transformInboundPrimaryKeysRequest(PrimaryKeysRequest request) {
284	request.setDb_name(metaStoreMapping.transformInboundDatabaseName(request.getDb_name()));	×
285	return request;	×
286	}
287
288	@Override
289	public PrimaryKeysResponse transformOutboundPrimaryKeysResponse(PrimaryKeysResponse response) {
290	for (SQLPrimaryKey key : response.getPrimaryKeys()) {	×
291	key.setTable_db(metaStoreMapping.transformOutboundDatabaseName(key.getTable_db()));	×
292	}
293	return response;	×
294	}
295
296	@Override
297	public TableMeta transformOutboundTableMeta(TableMeta tableMeta) {
298	tableMeta.setDbName(metaStoreMapping.transformOutboundDatabaseName(tableMeta.getDbName()));	×
299	return tableMeta;	×
300	}
301
302	@Override
303	public AddDynamicPartitions transformInboundAddDynamicPartitions(AddDynamicPartitions request) {
304	request.setDbname(metaStoreMapping.transformInboundDatabaseName(request.getDbname()));	×
305	return request;	×
306	}
307
308	@Override
309	public void close() throws IOException {
310	metaStoreMapping.close();	×
311	}	×
312
313	@Override
314	public boolean isAvailable() {
315	return metaStoreMapping.isAvailable();	×
316	}
317
318	@Override
319	public MetaStoreMapping checkWritePermissions(String databaseName) throws IllegalArgumentException {
320	return metaStoreMapping.checkWritePermissions(transformInboundDatabaseName(databaseName));	×
321	}
322
323	@Override
324	public DropConstraintRequest transformInboundDropConstraintRequest(DropConstraintRequest request) {
325	request.setDbname(metaStoreMapping.transformInboundDatabaseName(request.getDbname()));	×
326	return request;	×
327	}
328
329	@Override
330	public AddPartitionsRequest transformInboundAddPartitionsRequest(AddPartitionsRequest request) {
331	request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));	×
332	request.setParts(transformInboundPartitions(request.getParts()));	×
333	return request;	×
334	}
335
336	@Override
337	public AddPartitionsResult transformOutboundAddPartitionsResult(AddPartitionsResult result) {
338	result.setPartitions(transformOutboundPartitions(result.getPartitions()));	×
339	return result;	×
340	}
341
342	@Override
343	public DropPartitionsRequest transformInboundDropPartitionRequest(DropPartitionsRequest request) {
344	request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));	×
345	return request;	×
346	}
347
348	@Override
349	public DropPartitionsResult transformOutboundDropPartitionsResult(DropPartitionsResult result) {
350	result.setPartitions(transformOutboundPartitions(result.getPartitions()));	×
351	return result;	×
352	}
353
354	@Override
355	public List<Partition> transformOutboundPartitions(List<Partition> partitions) {
356	for (Partition partition : partitions) {	×
357	transformOutboundPartition(partition);	×
358	}
359	return partitions;	×
360	}
361
362	@Override
363	public List<PartitionSpec> transformOutboundPartitionSpecs(List<PartitionSpec> partitionSpecs) {
364	for (PartitionSpec partitionSpec : partitionSpecs) {	×
365	transformOutboundPartitionSpec(partitionSpec);	×
366	}
367	return partitionSpecs;	×
368	}
369
370	@Override
371	public List<Partition> transformInboundPartitions(List<Partition> partitions) {
372	for (Partition partition : partitions) {	×
373	transformInboundPartition(partition);	×
374	}
375	return partitions;	×
376	}
377
378	@Override
379	public List<Index> transformOutboundIndexes(List<Index> indexes) {
380	for (Index index : indexes) {	×
381	transformOutboundIndex(index);	×
382	}
383	return indexes;	×
384	}
385
386	@Override
387	public ColumnStatistics transformInboundColumnStatistics(ColumnStatistics columnStatistics) {
388	columnStatistics	×
389	.getStatsDesc()	×
390	.setDbName(metaStoreMapping.transformInboundDatabaseName(columnStatistics.getStatsDesc().getDbName()));	×
391	return columnStatistics;	×
392	}
393
394	@Override
395	public ColumnStatistics transformOutboundColumnStatistics(ColumnStatistics columnStatistics) {
396	columnStatistics	×
397	.getStatsDesc()	×
398	.setDbName(metaStoreMapping.transformOutboundDatabaseName(columnStatistics.getStatsDesc().getDbName()));	×
399	return columnStatistics;	×
400	}
401
402	@Override
403	public SetPartitionsStatsRequest transformInboundSetPartitionStatsRequest(SetPartitionsStatsRequest request) {
404	if (request.isSetColStats()) {	×
405	for (ColumnStatistics stats : request.getColStats()) {	×
406	transformInboundColumnStatistics(stats);	×
407	}
408	}
409	return request;	×
410	}
411
412	@Override
413	public Function transformInboundFunction(Function function) {
414	function.setDbName(metaStoreMapping.transformInboundDatabaseName(function.getDbName()));	×
415	return function;	×
416	}
417
418	@Override
419	public List<HiveObjectPrivilege> transformOutboundHiveObjectPrivileges(List<HiveObjectPrivilege> privileges) {
420	for (HiveObjectPrivilege privilege : privileges) {	×
421	privilege.setHiveObject(transformOutboundHiveObjectRef(privilege.getHiveObject()));	×
422	}
423	return privileges;	×
424	}
425
426	@Override
427	public PrivilegeBag transformInboundPrivilegeBag(PrivilegeBag privilegeBag) {
428	if (privilegeBag.isSetPrivileges()) {	×
429	for (HiveObjectPrivilege privilege : privilegeBag.getPrivileges()) {	×
430	privilege.setHiveObject(transformInboundHiveObjectRef(privilege.getHiveObject()));	×
431	}
432	}
433	return privilegeBag;	×
434	}
435
436	@Override
437	public GrantRevokePrivilegeRequest transformInboundGrantRevokePrivilegesRequest(GrantRevokePrivilegeRequest request) {
438	if (request.isSetPrivileges()) {	×
439	request.setPrivileges(transformInboundPrivilegeBag(request.getPrivileges()));	×
440	}
441	return request;	×
442	}
443
444	@Override
445	public LockRequest transformInboundLockRequest(LockRequest request) {
446	if (request.isSetComponent()) {	×
447	for (LockComponent component : request.getComponent()) {	×
448	component.setDbname(metaStoreMapping.transformInboundDatabaseName(component.getDbname()));	×
449	}
450	}
451	return request;	×
452	}
453
454	@Override
455	public CompactionRequest transformInboundCompactionRequest(CompactionRequest request) {
456	request.setDbname(metaStoreMapping.transformInboundDatabaseName(request.getDbname()));	×
457	return request;	×
458	}
459
460	@Override
461	public void createDatabase(Database database)
462	throws AlreadyExistsException, InvalidObjectException, MetaException, TException {
463	metaStoreMapping.createDatabase(database);	×
464	}	×
465
466	@Override
467	public Database transformInboundDatabase(Database database) {
468	database.setName(metaStoreMapping.transformInboundDatabaseName(database.getName()));	×
469	return database;	×
470	}
471
472	@Override
473	public List<PartitionSpec> transformInboundPartitionSpecs(List<PartitionSpec> partitionSpecs) {
474	for (PartitionSpec partitionSpec : partitionSpecs) {	×
475	partitionSpec.setDbName(metaStoreMapping.transformInboundDatabaseName(partitionSpec.getDbName()));	×
476	}
477	return partitionSpecs;	×
478	}
479
480	@Override
481	public GetTableRequest transformInboundGetTableRequest(GetTableRequest request) {
482	request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));	×
483	return request;	×
484	}
485
486	@Override
487	public GetTableResult transformOutboundGetTableResult(GetTableResult result) {
488	transformOutboundTable(result.getTable());	×
489	return result;	×
490	}
491
492	@Override
493	public GetTablesRequest transformInboundGetTablesRequest(GetTablesRequest request) {
494	request.setDbName(metaStoreMapping.transformInboundDatabaseName(request.getDbName()));	×
495	return request;	×
496	}
497
498	@Override
499	public GetTablesResult transformOutboundGetTablesResult(GetTablesResult result) {
500	for (Table table : result.getTables()) {	×
501	transformOutboundTable(table);	×
502	}
503	return result;	×
504	}
505
506	@Override
507	public PartitionValuesRequest transformInboundPartitionValuesRequest(PartitionValuesRequest request) {
508	request.setDbName(transformInboundDatabaseName(request.getDbName()));	×
509	return request;	×
510	}
511
512	@Override
513	public long getLatency() {
514	return metaStoreMapping.getLatency();	×
515	}
516
517	}

HotelsDotCom / waggle-dance / #318

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous