You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@phoenix.apache.org by vj...@apache.org on 2023/07/28 04:41:09 UTC
[phoenix] branch master updated: PHOENIX-6989 Expose server side metrics for DDL operations (#1638)
This is an automated email from the ASF dual-hosted git repository.
vjasani pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/phoenix.git
The following commit(s) were added to refs/heads/master by this push:
new 4883080c7b PHOENIX-6989 Expose server side metrics for DDL operations (#1638)
4883080c7b is described below
commit 4883080c7ba72351158db0bae8634cb65dd750f3
Author: Jing Yu <yu...@salesforce.com>
AuthorDate: Fri Jul 28 00:41:04 2023 -0400
PHOENIX-6989 Expose server side metrics for DDL operations (#1638)
---
.../phoenix/monitoring/MetadataMetricsIT.java | 108 +++++++++++++++++++++
.../phoenix/coprocessor/MetaDataEndpointImpl.java | 63 ++++++++++--
.../schema/metrics/MetricsMetadataSource.java | 98 +++++++++++++++++++
.../schema/metrics/MetricsMetadataSourceImpl.java | 89 +++++++++++++++++
4 files changed, 352 insertions(+), 6 deletions(-)
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/monitoring/MetadataMetricsIT.java b/phoenix-core/src/it/java/org/apache/phoenix/monitoring/MetadataMetricsIT.java
index 9e72a56259..ad0cc917bb 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/monitoring/MetadataMetricsIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/monitoring/MetadataMetricsIT.java
@@ -81,4 +81,112 @@ public class MetadataMetricsIT extends ParallelStatsDisabledIT {
metadataSource.updateAlterExportFailureTime(time);
IndexMetricsIT.verifyHistogram(MetricsMetadataSource.ALTER_EXPORT_FAILURE_TIME, registry, time);
}
+
+ @Test
+ public void testCreateTableMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementCreateTableCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.CREATE_TABLE_COUNT, registry);
+ }
+
+ @Test
+ public void testCreateViewMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementCreateViewCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.CREATE_VIEW_COUNT, registry);
+ }
+
+ @Test
+ public void testCreateIndexMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementCreateIndexCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.CREATE_INDEX_COUNT, registry);
+ }
+
+ @Test
+ public void testCreateSchemaMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementCreateSchemaCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.CREATE_SCHEMA_COUNT, registry);
+ }
+
+ @Test
+ public void testCreateFunctionMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementCreateFunctionCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.CREATE_FUNCTION_COUNT, registry);
+ }
+
+ @Test
+ public void testAlterAddColumnsMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementAlterAddColumnCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.ALTER_ADD_COLUMN_COUNT, registry);
+ }
+
+ @Test
+ public void testAlterDropColumnsMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementAlterDropColumnCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.ALTER_DROP_COLUMN_COUNT, registry);
+ }
+
+ @Test
+ public void testDropTableMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementDropTableCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.DROP_TABLE_COUNT, registry);
+ }
+
+ @Test
+ public void testDropViewMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementDropViewCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.DROP_VIEW_COUNT, registry);
+ }
+
+ @Test
+ public void testDropIndexMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementDropIndexCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.DROP_INDEX_COUNT, registry);
+ }
+
+ @Test
+ public void testDropSchemaMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementDropSchemaCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.DROP_SCHEMA_COUNT, registry);
+ }
+
+ @Test
+ public void testDropFunctionMetrics() {
+ MetricsMetadataSourceImpl metadataSource = new MetricsMetadataSourceImpl();
+ DynamicMetricsRegistry registry = metadataSource.getMetricsRegistry();
+
+ metadataSource.incrementDropFunctionCount();
+ IndexMetricsIT.verifyCounter(MetricsMetadataSource.DROP_FUNCTION_COUNT, registry);
+ }
}
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/MetaDataEndpointImpl.java b/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/MetaDataEndpointImpl.java
index 149afee79b..7db23f4678 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/MetaDataEndpointImpl.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/MetaDataEndpointImpl.java
@@ -138,9 +138,7 @@ import org.apache.hadoop.hbase.coprocessor.CoprocessorException;
import org.apache.hadoop.hbase.coprocessor.CoreCoprocessor;
import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor;
import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
-import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter;
-import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.ipc.RpcCall;
import org.apache.hadoop.hbase.ipc.RpcUtil;
@@ -2494,6 +2492,9 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
}
done.run(builder.build());
+
+ updateCreateTableDdlSuccessMetrics(tableType);
+ LOGGER.info("{} created successfully, tableName: {}", tableType, fullTableName);
} finally {
ServerUtil.releaseRowLocks(locks);
}
@@ -2504,6 +2505,16 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
}
}
+ private void updateCreateTableDdlSuccessMetrics(PTableType tableType) {
+ if (tableType == PTableType.TABLE || tableType == PTableType.SYSTEM) {
+ metricsSource.incrementCreateTableCount();
+ } else if (tableType == PTableType.VIEW) {
+ metricsSource.incrementCreateViewCount();
+ } else if (tableType == PTableType.INDEX) {
+ metricsSource.incrementCreateIndexCount();
+ }
+ }
+
private void exportSchema(List<Mutation> tableMetadata, byte[] tableKey, long clientTimestamp,
int clientVersion, PTable oldTable) throws SQLException, IOException {
List<Cell> tableCellList = MetaDataUtil.getTableCellsFromMutations(tableMetadata);
@@ -2611,6 +2622,7 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
byte[] tenantIdBytes = rowKeyMetaData[PhoenixDatabaseMetaData.TENANT_ID_INDEX];
schemaName = rowKeyMetaData[PhoenixDatabaseMetaData.SCHEMA_NAME_INDEX];
tableOrViewName = rowKeyMetaData[PhoenixDatabaseMetaData.TABLE_NAME_INDEX];
+ String fullTableName = SchemaUtil.getTableName(schemaName, tableOrViewName);
PTableType pTableType = PTableType.fromSerializedValue(tableType);
// Disallow deletion of a system table
if (pTableType == PTableType.SYSTEM) {
@@ -2795,6 +2807,9 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
done.run(MetaDataMutationResult.toProto(result));
dropTableStats = true;
+
+ updateDropTableDdlSuccessMetrics(pTableType);
+ LOGGER.info("{} dropped successfully, tableName: {}", pTableType, fullTableName);
} finally {
ServerUtil.releaseRowLocks(locks);
if (dropTableStats) {
@@ -2812,6 +2827,16 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
}
}
+ private void updateDropTableDdlSuccessMetrics(PTableType pTableType) {
+ if (pTableType == PTableType.TABLE || pTableType == PTableType.SYSTEM) {
+ metricsSource.incrementDropTableCount();
+ } else if (pTableType == PTableType.VIEW) {
+ metricsSource.incrementDropViewCount();
+ } else if (pTableType == PTableType.INDEX) {
+ metricsSource.incrementDropIndexCount();
+ }
+ }
+
private static class StatsDeleteHandler implements Runnable {
PTable deletedTable;
List<byte[]> physicalTableNames;
@@ -3497,6 +3522,12 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
request.getClientVersion(), parentTable, transformingNewTable, addingColumns);
if (result != null) {
done.run(MetaDataMutationResult.toProto(result));
+
+ if (result.getMutationCode() == MutationCode.TABLE_ALREADY_EXISTS) {
+ metricsSource.incrementAlterAddColumnCount();
+ LOGGER.info("Column(s) added successfully, tableName: {}",
+ result.getTable().getTableName());
+ }
}
} catch (Throwable e) {
LOGGER.error("Add column failed: ", e);
@@ -3635,6 +3666,12 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
request.getClientVersion(), parentTable,null, true);
if (result != null) {
done.run(MetaDataMutationResult.toProto(result));
+
+ if (result.getMutationCode() == MutationCode.TABLE_ALREADY_EXISTS) {
+ metricsSource.incrementAlterDropColumnCount();
+ LOGGER.info("Column(s) dropped successfully, tableName: {}",
+ result.getTable().getTableName());
+ }
}
} catch (Throwable e) {
LOGGER.error("Drop column failed: ", e);
@@ -3703,6 +3740,10 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
if (result.getMutationCode() != MutationCode.TABLE_ALREADY_EXISTS) {
return result;
}
+ metricsSource.incrementDropIndexCount();
+ LOGGER.info("INDEX dropped successfully, tableName: {}",
+ result.getTable().getTableName());
+
// there should be no child links to delete since we are just dropping an index
if (!childLinksMutations.isEmpty()) {
LOGGER.error("Found unexpected child link mutations while dropping an index "
@@ -4368,7 +4409,10 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
builder.setReturnCode(MetaDataProtos.MutationCode.FUNCTION_NOT_FOUND);
builder.setMutationTime(currentTimeStamp);
done.run(builder.build());
- return;
+
+ metricsSource.incrementCreateFunctionCount();
+ LOGGER.info("FUNCTION created successfully, functionName: {}",
+ Bytes.toString(functionName));
} finally {
ServerUtil.releaseRowLocks(locks);
}
@@ -4421,7 +4465,10 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
}
done.run(MetaDataMutationResult.toProto(result));
- return;
+
+ metricsSource.incrementDropFunctionCount();
+ LOGGER.info("FUNCTION dropped successfully, functionName: {}",
+ Bytes.toString(functionName));
} finally {
ServerUtil.releaseRowLocks(locks);
}
@@ -4542,7 +4589,9 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
builder.setReturnCode(MetaDataProtos.MutationCode.SCHEMA_NOT_FOUND);
builder.setMutationTime(currentTimeStamp);
done.run(builder.build());
- return;
+
+ metricsSource.incrementCreateSchemaCount();
+ LOGGER.info("SCHEMA created successfully, schemaName: {}", schemaName);
} finally {
ServerUtil.releaseRowLocks(locks);
}
@@ -4586,7 +4635,9 @@ TABLE_FAMILY_BYTES, TABLE_SEQ_NUM_BYTES);
metaDataCache.put(ptr, newDeletedSchemaMarker(currentTime));
}
done.run(MetaDataMutationResult.toProto(result));
- return;
+
+ metricsSource.incrementDropSchemaCount();
+ LOGGER.info("SCHEMA dropped successfully, schemaName: {}", schemaName);
} finally {
ServerUtil.releaseRowLocks(locks);
}
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/metrics/MetricsMetadataSource.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/metrics/MetricsMetadataSource.java
index bab1c05ea9..8ed65a93cf 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/metrics/MetricsMetadataSource.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/metrics/MetricsMetadataSource.java
@@ -52,6 +52,44 @@ public interface MetricsMetadataSource {
String ALTER_EXPORT_FAILURE_TIME_DESC = "Time taken while failing to export "
+ "ALTER DDL to schema registry";
+ String CREATE_TABLE_COUNT = "createTableCount";
+ String CREATE_TABLE_COUNT_DESC = "Count of CREATE TABLE DDL statements";
+
+ String CREATE_VIEW_COUNT = "createViewCount";
+ String CREATE_VIEW_COUNT_DESC = "Count of CREATE VIEW DDL statements";
+
+ String CREATE_INDEX_COUNT = "createIndexCount";
+ String CREATE_INDEX_COUNT_DESC = "Count of CREATE INDEX DDL statements";
+
+ String CREATE_SCHEMA_COUNT = "createSchemaCount";
+ String CREATE_SCHEMA_COUNT_DESC = "Count of CREATE SCHEMA DDL statements";
+
+ String CREATE_FUNCTION_COUNT = "createFunctionCount";
+ String CREATE_FUNCTION_COUNT_DESC = "Count of CREATE FUNCTION DDL statements";
+
+ String ALTER_ADD_COLUMN_COUNT = "alterAddColumnCount";
+ String ALTER_ADD_COLUMN_COUNT_DESC = "Count of ALTER statements that add columns";
+
+ String ALTER_DROP_COLUMN_COUNT = "alterDropColumnCount";
+ String ALTER_DROP_COLUMN_COUNT_DESC = "Count of ALTER statements that drop columns";
+
+ String DROP_TABLE_COUNT = "dropTableCount";
+ String DROP_TABLE_COUNT_DESC = "Count of DROP TABLE DDL statements";
+
+ String DROP_VIEW_COUNT = "dropViewCount";
+ String DROP_VIEW_COUNT_DESC = "Count of DROP VIEW DDL statements";
+
+ String DROP_INDEX_COUNT = "dropIndexCount";
+ String DROP_INDEX_COUNT_DESC = "Count of DROP INDEX DDL statements";
+
+ String DROP_SCHEMA_COUNT = "dropSchemaCount";
+ String DROP_SCHEMA_COUNT_DESC = "Count of DROP SCHEMA DDL statements";
+
+ String DROP_FUNCTION_COUNT = "dropFunctionCount";
+ String DROP_FUNCTION_COUNT_DESC = "Count of DROP FUNCTION DDL statements";
+
+ // TODO: metrics for addIndexToTable and dropIndexes
+
/**
* Updates the count of successful requests to the schema registry for CREATE statements
*/
@@ -97,4 +135,64 @@ public interface MetricsMetadataSource {
* @param t time taken
*/
void updateAlterExportFailureTime(long t);
+
+ /**
+ * Updates the count of successful CREATE TABLE DDL operations
+ */
+ void incrementCreateTableCount();
+
+ /**
+ * Updates the count of successful CREATE VIEW DDL operations
+ */
+ void incrementCreateViewCount();
+
+ /**
+ * Updates the count of successful CREATE INDEX DDL operations
+ */
+ void incrementCreateIndexCount();
+
+ /**
+ * Updates the count of successful CREATE SCHEMA DDL operations
+ */
+ void incrementCreateSchemaCount();
+
+ /**
+ * Updates the count of successful CREATE FUNCTION DDL operations
+ */
+ void incrementCreateFunctionCount();
+
+ /**
+ * Updates the count of successful ALTER DDL operations that add columns
+ */
+ void incrementAlterAddColumnCount();
+
+ /**
+ * Updates the count of successful ALTER DDL operations that drop columns
+ */
+ void incrementAlterDropColumnCount();
+
+ /**
+ * Updates the count of successful DROP TABLE DDL operations
+ */
+ void incrementDropTableCount();
+
+ /**
+ * Updates the count of successful DROP VIEW DDL operations
+ */
+ void incrementDropViewCount();
+
+ /**
+ * Updates the count of successful DROP INDEX DDL operations
+ */
+ void incrementDropIndexCount();
+
+ /**
+ * Updates the count of successful DROP SCHEMA DDL operations
+ */
+ void incrementDropSchemaCount();
+
+ /**
+ * Updates the count of successful DROP FUNCTION DDL operations
+ */
+ void incrementDropFunctionCount();
}
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/metrics/MetricsMetadataSourceImpl.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/metrics/MetricsMetadataSourceImpl.java
index 8d0e024754..d887ad539c 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/metrics/MetricsMetadataSourceImpl.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/metrics/MetricsMetadataSourceImpl.java
@@ -35,6 +35,21 @@ public class MetricsMetadataSourceImpl extends BaseSourceImpl implements Metrics
private final MutableFastCounter alterExportFailureCount;
private final MetricHistogram alterExportFailureTimeHisto;
+ private final MutableFastCounter createTableCount;
+ private final MutableFastCounter createViewCount;
+ private final MutableFastCounter createIndexCount;
+ private final MutableFastCounter createSchemaCount;
+ private final MutableFastCounter createFunctionCount;
+
+ private final MutableFastCounter alterAddColumnCount;
+ private final MutableFastCounter alterDropColumnCount;
+
+ private final MutableFastCounter dropTableCount;
+ private final MutableFastCounter dropViewCount;
+ private final MutableFastCounter dropIndexCount;
+ private final MutableFastCounter dropSchemaCount;
+ private final MutableFastCounter dropFunctionCount;
+
public MetricsMetadataSourceImpl() {
this(METRICS_NAME, METRICS_DESCRIPTION, METRICS_CONTEXT, METRICS_JMX_CONTEXT);
}
@@ -61,6 +76,32 @@ public class MetricsMetadataSourceImpl extends BaseSourceImpl implements Metrics
alterExportFailureTimeHisto = getMetricsRegistry().newHistogram(ALTER_EXPORT_FAILURE_TIME,
ALTER_EXPORT_FAILURE_TIME_DESC);
+ createTableCount = getMetricsRegistry().newCounter(CREATE_TABLE_COUNT,
+ CREATE_TABLE_COUNT_DESC, 0L);
+ createViewCount = getMetricsRegistry().newCounter(CREATE_VIEW_COUNT,
+ CREATE_VIEW_COUNT_DESC, 0L);
+ createIndexCount = getMetricsRegistry().newCounter(CREATE_INDEX_COUNT,
+ CREATE_INDEX_COUNT_DESC, 0L);
+ createFunctionCount = getMetricsRegistry().newCounter(CREATE_FUNCTION_COUNT,
+ CREATE_FUNCTION_COUNT_DESC, 0L);
+ createSchemaCount = getMetricsRegistry().newCounter(CREATE_SCHEMA_COUNT,
+ CREATE_SCHEMA_COUNT_DESC, 0L);
+
+ alterAddColumnCount = getMetricsRegistry().newCounter(ALTER_ADD_COLUMN_COUNT,
+ ALTER_ADD_COLUMN_COUNT_DESC, 0L);
+ alterDropColumnCount = getMetricsRegistry().newCounter(ALTER_DROP_COLUMN_COUNT,
+ ALTER_DROP_COLUMN_COUNT_DESC, 0L);
+
+ dropTableCount = getMetricsRegistry().newCounter(DROP_TABLE_COUNT,
+ DROP_TABLE_COUNT_DESC, 0L);
+ dropViewCount = getMetricsRegistry().newCounter(DROP_VIEW_COUNT,
+ DROP_VIEW_COUNT_DESC, 0L);
+ dropIndexCount = getMetricsRegistry().newCounter(DROP_INDEX_COUNT,
+ DROP_INDEX_COUNT_DESC, 0L);
+ dropSchemaCount = getMetricsRegistry().newCounter(DROP_SCHEMA_COUNT,
+ DROP_SCHEMA_COUNT_DESC, 0L);
+ dropFunctionCount = getMetricsRegistry().newCounter(DROP_FUNCTION_COUNT,
+ DROP_FUNCTION_COUNT_DESC, 0L);
}
@Override public void incrementCreateExportCount() {
@@ -94,4 +135,52 @@ public class MetricsMetadataSourceImpl extends BaseSourceImpl implements Metrics
@Override public void updateAlterExportFailureTime(long t) {
alterExportFailureTimeHisto.add(t);
}
+
+ @Override public void incrementCreateTableCount() {
+ createTableCount.incr();
+ }
+
+ @Override public void incrementCreateViewCount() {
+ createViewCount.incr();
+ }
+
+ @Override public void incrementCreateIndexCount() {
+ createIndexCount.incr();
+ }
+
+ @Override public void incrementCreateSchemaCount() {
+ createSchemaCount.incr();
+ }
+
+ @Override public void incrementCreateFunctionCount() {
+ createFunctionCount.incr();
+ }
+
+ @Override public void incrementAlterAddColumnCount() {
+ alterAddColumnCount.incr();
+ }
+
+ @Override public void incrementAlterDropColumnCount() {
+ alterDropColumnCount.incr();
+ }
+
+ @Override public void incrementDropTableCount() {
+ dropTableCount.incr();
+ }
+
+ @Override public void incrementDropViewCount() {
+ dropViewCount.incr();
+ }
+
+ @Override public void incrementDropIndexCount() {
+ dropIndexCount.incr();
+ }
+
+ @Override public void incrementDropSchemaCount() {
+ dropSchemaCount.incr();
+ }
+
+ @Override public void incrementDropFunctionCount() {
+ dropFunctionCount.incr();
+ }
}