cache;
+
+ HazelcastIMapAdapter(Object cache) {
+ this.cache = new WeakReference<>(cache);
+ }
+
+ static String nameOf(Object cache) {
+ try {
+ return (String) GET_NAME.invoke(cache);
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+
+ @Nullable
+ LocalMapStats getLocalMapStats() {
+ Object ref = cache.get();
+ if (ref == null) {
+ return null;
+ }
+
+ Object result = invoke(GET_LOCAL_MAP_STATS, ref);
+ return result == null ? null : new LocalMapStats(result);
+ }
+
+ static class LocalMapStats {
+ private static final MethodHandle GET_NEAR_CACHE_STATS;
+
+ private static final MethodHandle GET_OWNED_ENTRY_COUNT;
+ private static final MethodHandle GET_HITS;
+ private static final MethodHandle GET_PUT_OPERATION_COUNT;
+ private static final MethodHandle GET_BACKUP_ENTRY_COUNT;
+ private static final MethodHandle GET_BACKUP_ENTRY_MEMORY_COST;
+ private static final MethodHandle GET_OWNED_ENTRY_MEMORY_COST;
+ private static final MethodHandle GET_GET_OPERATION_COUNT;
+ private static final MethodHandle GET_TOTAL_GET_LATENCY;
+ private static final MethodHandle GET_TOTAL_PUT_LATENCY;
+ private static final MethodHandle GET_REMOVE_OPERATION_COUNT;
+ private static final MethodHandle GET_TOTAL_REMOVE_LATENCY;
+
+ static {
+ GET_NEAR_CACHE_STATS = resolveMethod("getNearCacheStats", methodType(CLASS_NEAR_CACHE_STATS));
+
+ GET_OWNED_ENTRY_COUNT = resolveMethod("getOwnedEntryCount", methodType(long.class));
+ GET_HITS = resolveMethod("getHits", methodType(long.class));
+ GET_PUT_OPERATION_COUNT = resolveMethod("getPutOperationCount", methodType(long.class));
+ GET_BACKUP_ENTRY_COUNT = resolveMethod("getBackupEntryCount", methodType(long.class));
+ GET_BACKUP_ENTRY_MEMORY_COST = resolveMethod("getBackupEntryMemoryCost", methodType(long.class));
+ GET_OWNED_ENTRY_MEMORY_COST = resolveMethod("getOwnedEntryMemoryCost", methodType(long.class));
+ GET_GET_OPERATION_COUNT = resolveMethod("getGetOperationCount", methodType(long.class));
+ GET_TOTAL_GET_LATENCY = resolveMethod("getTotalGetLatency", methodType(long.class));
+ GET_TOTAL_PUT_LATENCY = resolveMethod("getTotalPutLatency", methodType(long.class));
+ GET_REMOVE_OPERATION_COUNT = resolveMethod("getRemoveOperationCount", methodType(long.class));
+ GET_TOTAL_REMOVE_LATENCY = resolveMethod("getTotalRemoveLatency", methodType(long.class));
+ }
+
+ private final Object localMapStats;
+
+ LocalMapStats(Object localMapStats) {
+ this.localMapStats = localMapStats;
+ }
+
+ long getOwnedEntryCount() {
+ return (long) invoke(GET_OWNED_ENTRY_COUNT, localMapStats);
+ }
+
+ long getHits() {
+ return (long) invoke(GET_HITS, localMapStats);
+ }
+
+ long getPutOperationCount() {
+ return (long) invoke(GET_PUT_OPERATION_COUNT, localMapStats);
+ }
+
+ double getBackupEntryCount() {
+ return (long) invoke(GET_BACKUP_ENTRY_COUNT, localMapStats);
+ }
+
+ long getBackupEntryMemoryCost() {
+ return (long) invoke(GET_BACKUP_ENTRY_MEMORY_COST, localMapStats);
+ }
+
+ long getOwnedEntryMemoryCost() {
+ return (long) invoke(GET_OWNED_ENTRY_MEMORY_COST, localMapStats);
+ }
+
+ long getGetOperationCount() {
+ return (long) invoke(GET_GET_OPERATION_COUNT, localMapStats);
+ }
+
+ NearCacheStats getNearCacheStats() {
+ Object result = invoke(GET_NEAR_CACHE_STATS, localMapStats);
+ return result == null ? null : new NearCacheStats(result);
+ }
+
+ long getTotalGetLatency() {
+ return (long) invoke(GET_TOTAL_GET_LATENCY, localMapStats);
+ }
+
+ long getTotalPutLatency() {
+ return (long) invoke(GET_TOTAL_PUT_LATENCY, localMapStats);
+ }
+
+ long getRemoveOperationCount() {
+ return (long) invoke(GET_REMOVE_OPERATION_COUNT, localMapStats);
+ }
+
+ long getTotalRemoveLatency() {
+ return (long) invoke(GET_TOTAL_REMOVE_LATENCY, localMapStats);
+ }
+
+ private static MethodHandle resolveMethod(String name, MethodType mt) {
+ try {
+ return MethodHandles.publicLookup().findVirtual(CLASS_LOCAL_MAP, name, mt);
+ } catch (NoSuchMethodException | IllegalAccessException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+ }
+
+ static class NearCacheStats {
+ private static final MethodHandle GET_HITS;
+ private static final MethodHandle GET_MISSES;
+ private static final MethodHandle GET_EVICTIONS;
+ private static final MethodHandle GET_PERSISTENCE_COUNT;
+
+ static {
+ GET_HITS = resolveMethod("getHits", methodType(long.class));
+ GET_MISSES = resolveMethod("getMisses", methodType(long.class));
+ GET_EVICTIONS = resolveMethod("getEvictions", methodType(long.class));
+ GET_PERSISTENCE_COUNT = resolveMethod("getPersistenceCount", methodType(long.class));
+ }
+
+ private Object nearCacheStats;
+
+ NearCacheStats(Object nearCacheStats) {
+ this.nearCacheStats = nearCacheStats;
+ }
+
+ long getHits() {
+ return (long) invoke(GET_HITS, nearCacheStats);
+ }
+
+ long getMisses() {
+ return (long) invoke(GET_MISSES, nearCacheStats);
+ }
+
+ long getEvictions() {
+ return (long) invoke(GET_EVICTIONS, nearCacheStats);
+ }
+
+ long getPersistenceCount() {
+ return (long) invoke(GET_PERSISTENCE_COUNT, nearCacheStats);
+ }
+
+ private static MethodHandle resolveMethod(String name, MethodType mt) {
+ try {
+ return MethodHandles.publicLookup().findVirtual(CLASS_NEAR_CACHE_STATS, name, mt);
+ } catch (NoSuchMethodException | IllegalAccessException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+ }
+
+ private static MethodHandle resolveIMapMethod(String name, MethodType mt) {
+ try {
+ return MethodHandles.publicLookup().findVirtual(CLASS_I_MAP, name, mt);
+ } catch (NoSuchMethodException | IllegalAccessException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private static Class resolveOneOf(String class1, String class2) {
+ try {
+ return Class.forName(class1);
+ } catch (ClassNotFoundException e) {
+ try {
+ return Class.forName(class2);
+ } catch (ClassNotFoundException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+ }
+
+ private static Object invoke(MethodHandle mh, Object object) {
+ try {
+ return mh.invoke(object);
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/cache/JCacheMetrics.java b/micrometer-binders/src/main/java/io/micrometer/binder/cache/JCacheMetrics.java
new file mode 100644
index 0000000000..e5e9865ad4
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/cache/JCacheMetrics.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2017 VMware, 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
+ *
+ * https://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 io.micrometer.binder.cache;
+
+import java.util.List;
+
+import javax.cache.Cache;
+import javax.cache.CacheManager;
+import javax.management.AttributeNotFoundException;
+import javax.management.InstanceNotFoundException;
+import javax.management.MBeanException;
+import javax.management.MBeanServer;
+import javax.management.MBeanServerFactory;
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectName;
+import javax.management.ReflectionException;
+
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.binder.cache.CacheMeterBinder;
+import io.micrometer.core.instrument.config.InvalidConfigurationException;
+import io.micrometer.core.lang.NonNullApi;
+import io.micrometer.core.lang.NonNullFields;
+import io.micrometer.core.lang.Nullable;
+
+/**
+ * Collect metrics on JSR-107 JCache caches, including detailed metrics on manual puts and removals.
+ * See https://github.com/jsr107/demo/blob/master/src/test/java/javax/cache/core/StatisticsExample.java
+ *
+ * Note that JSR-107 does not provide any insight into the size or estimated size of the cache, so
+ * the size metric of a JCache cache will always report 0.
+ *
+ * @author Jon Schneider
+ */
+@NonNullApi
+@NonNullFields
+public class JCacheMetrics> extends CacheMeterBinder {
+ // VisibleForTesting
+ @Nullable
+ ObjectName objectName;
+
+ /**
+ * Record metrics on a JCache cache.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param tags Tags to apply to all recorded metrics. Must be an even number of arguments representing key/value pairs of tags.
+ * @param The cache type.
+ * @param The cache key type.
+ * @param The cache value type.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ */
+ public static > C monitor(MeterRegistry registry, C cache, String... tags) {
+ return monitor(registry, cache, Tags.of(tags));
+ }
+
+ /**
+ * Record metrics on a JCache cache.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param tags Tags to apply to all recorded metrics.
+ * @param The cache type.
+ * @param The cache key type.
+ * @param The cache value type.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ */
+ public static > C monitor(MeterRegistry registry, C cache, Iterable tags) {
+ new JCacheMetrics<>(cache, tags).bindTo(registry);
+ return cache;
+ }
+
+ public JCacheMetrics(C cache, Iterable tags) {
+ super(cache, cache.getName(), tags);
+ try {
+ CacheManager cacheManager = cache.getCacheManager();
+ if (cacheManager != null) {
+ String cacheManagerUri = cacheManager.getURI().toString()
+ .replace(':', '.'); // ehcache's uri is prefixed with 'urn:'
+
+ this.objectName = new ObjectName("javax.cache:type=CacheStatistics"
+ + ",CacheManager=" + cacheManagerUri
+ + ",Cache=" + cache.getName());
+ }
+ } catch (MalformedObjectNameException ignored) {
+ throw new InvalidConfigurationException("Cache name '" + cache.getName() + "' results in an invalid JMX name");
+ }
+ }
+
+ @Override
+ protected Long size() {
+ // JCache statistics don't support size
+ return null;
+ }
+
+ @Override
+ protected long hitCount() {
+ return lookupStatistic("CacheHits");
+ }
+
+ @Override
+ protected Long missCount() {
+ return lookupStatistic("CacheMisses");
+ }
+
+ @Override
+ protected Long evictionCount() {
+ return lookupStatistic("CacheEvictions");
+ }
+
+ @Override
+ protected long putCount() {
+ return lookupStatistic("CachePuts");
+ }
+
+ @Override
+ protected void bindImplementationSpecificMetrics(MeterRegistry registry) {
+ if (objectName != null) {
+ Gauge.builder("cache.removals", objectName, objectName -> lookupStatistic("CacheRemovals"))
+ .tags(getTagsWithCacheName())
+ .description("Cache removals")
+ .register(registry);
+ }
+ }
+
+ private Long lookupStatistic(String name) {
+ if (objectName != null) {
+ try {
+ List mBeanServers = MBeanServerFactory.findMBeanServer(null);
+ for (MBeanServer mBeanServer : mBeanServers) {
+ try {
+ return (Long) mBeanServer.getAttribute(objectName, name);
+ } catch (AttributeNotFoundException | InstanceNotFoundException ex) {
+ // did not find MBean, try the next server
+ }
+ }
+ } catch (MBeanException | ReflectionException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+
+ // didn't find the MBean in any servers
+ return 0L;
+ }
+}
diff --git a/micrometer-api/src/main/java/io/micrometer/api/instrument/step/package-info.java b/micrometer-binders/src/main/java/io/micrometer/binder/cache/package-info.java
similarity index 80%
rename from micrometer-api/src/main/java/io/micrometer/api/instrument/step/package-info.java
rename to micrometer-binders/src/main/java/io/micrometer/binder/cache/package-info.java
index 5a7121a206..c9514ec207 100644
--- a/micrometer-api/src/main/java/io/micrometer/api/instrument/step/package-info.java
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/cache/package-info.java
@@ -14,8 +14,6 @@
* limitations under the License.
*/
@NonNullApi
-@NonNullFields
-package io.micrometer.api.instrument.step;
+package io.micrometer.binder.cache;
-import io.micrometer.api.lang.NonNullApi;
-import io.micrometer.api.lang.NonNullFields;
+import io.micrometer.core.lang.NonNullApi;
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/commonspool2/CommonsObjectPool2Metrics.java b/micrometer-binders/src/main/java/io/micrometer/binder/commonspool2/CommonsObjectPool2Metrics.java
new file mode 100644
index 0000000000..502a2d4b2d
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/commonspool2/CommonsObjectPool2Metrics.java
@@ -0,0 +1,339 @@
+/*
+ * Copyright 2020 VMware, 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
+ *
+ * https://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 io.micrometer.binder.commonspool2;
+
+import java.lang.management.ManagementFactory;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.ToDoubleFunction;
+
+import javax.management.AttributeNotFoundException;
+import javax.management.InstanceNotFoundException;
+import javax.management.ListenerNotFoundException;
+import javax.management.MBeanException;
+import javax.management.MBeanServer;
+import javax.management.MBeanServerDelegate;
+import javax.management.MBeanServerFactory;
+import javax.management.MBeanServerNotification;
+import javax.management.MalformedObjectNameException;
+import javax.management.NotificationFilter;
+import javax.management.NotificationListener;
+import javax.management.ObjectName;
+import javax.management.ReflectionException;
+
+import io.micrometer.core.instrument.FunctionCounter;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.Meter;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.TimeGauge;
+import io.micrometer.core.instrument.binder.BaseUnits;
+import io.micrometer.core.instrument.binder.MeterBinder;
+import io.micrometer.core.instrument.util.NamedThreadFactory;
+import io.micrometer.core.lang.NonNull;
+import io.micrometer.core.lang.Nullable;
+import io.micrometer.core.util.internal.logging.InternalLogger;
+import io.micrometer.core.util.internal.logging.InternalLoggerFactory;
+
+import static java.util.Collections.emptyList;
+
+/**
+ * Apache Commons Pool 2.x metrics collected from metrics exposed via the MBeanServer.
+ * Metrics are exposed for each object pool.
+ *
+ * @author Chao Chang
+ * @since 1.6.0
+ */
+public class CommonsObjectPool2Metrics implements MeterBinder, AutoCloseable {
+ private static final InternalLogger log = InternalLoggerFactory.getInstance(CommonsObjectPool2Metrics.class);
+ private static final String JMX_DOMAIN = "org.apache.commons.pool2";
+ private static final String METRIC_NAME_PREFIX = "commons.pool2.";
+
+ private static final String[] TYPES = new String[]{"GenericObjectPool", "GenericKeyedObjectPool"};
+
+ private final ExecutorService executor = Executors.newSingleThreadExecutor(new NamedThreadFactory("commons-pool-metrics-updater"));
+
+ private final MBeanServer mBeanServer;
+ private final Iterable tags;
+ private final List notificationListenerCleanUpRunnables = new CopyOnWriteArrayList<>();
+
+ public CommonsObjectPool2Metrics() {
+ this(emptyList());
+ }
+
+ public CommonsObjectPool2Metrics(Iterable tags) {
+ this(getMBeanServer(), tags);
+ }
+
+ public CommonsObjectPool2Metrics(MBeanServer mBeanServer, Iterable tags) {
+ this.mBeanServer = mBeanServer;
+ this.tags = tags;
+ }
+
+ private static MBeanServer getMBeanServer() {
+ List mBeanServers = MBeanServerFactory.findMBeanServer(null);
+ if (!mBeanServers.isEmpty()) {
+ return mBeanServers.get(0);
+ }
+ return ManagementFactory.getPlatformMBeanServer();
+ }
+
+ @Override
+ public void bindTo(@NonNull MeterRegistry registry) {
+ for (String type : TYPES) {
+ registerMetricsEventually(
+ type,
+ (o, tags) -> {
+ registerGaugeForObject(registry, o,
+ "NumIdle", "num.idle", tags,
+ "The number of instances currently idle in this pool", BaseUnits.OBJECTS);
+ registerGaugeForObject(registry, o,
+ "NumActive", "num.active", tags,
+ "The number of instances currently active in this pool", BaseUnits.OBJECTS);
+ registerGaugeForObject(registry, o,
+ "NumWaiters", "num.waiters", tags,
+ "The estimate of the number of threads currently blocked waiting for an object from the pool",
+ BaseUnits.THREADS);
+
+ registerFunctionCounterForObject(registry, o,
+ "CreatedCount", "created", tags,
+ "The total number of objects created for this pool over the lifetime of the pool",
+ BaseUnits.OBJECTS);
+ registerFunctionCounterForObject(registry, o,
+ "BorrowedCount", "borrowed", tags,
+ "The total number of objects successfully borrowed from this pool over the lifetime of the pool",
+ BaseUnits.OBJECTS);
+ registerFunctionCounterForObject(registry, o,
+ "ReturnedCount", "returned", tags,
+ "The total number of objects returned to this pool over the lifetime of the pool",
+ BaseUnits.OBJECTS);
+ registerFunctionCounterForObject(registry, o,
+ "DestroyedCount", "destroyed", tags,
+ "The total number of objects destroyed by this pool over the lifetime of the pool",
+ BaseUnits.OBJECTS);
+ registerFunctionCounterForObject(registry, o,
+ "DestroyedByEvictorCount", "destroyed.by.evictor", tags,
+ "The total number of objects destroyed by the evictor associated with this pool over the lifetime of the pool",
+ BaseUnits.OBJECTS);
+ registerFunctionCounterForObject(registry, o,
+ "DestroyedByBorrowValidationCount", "destroyed.by.borrow.validation", tags,
+ "The total number of objects destroyed by this pool as a result of failing validation during borrowObject() over the lifetime of the pool",
+ BaseUnits.OBJECTS);
+
+ registerTimeGaugeForObject(registry, o,
+ "MaxBorrowWaitTimeMillis", "max.borrow.wait", tags,
+ "The maximum time a thread has waited to borrow objects from the pool");
+ registerTimeGaugeForObject(registry, o,
+ "MeanActiveTimeMillis", "mean.active", tags,
+ "The mean time objects are active");
+ registerTimeGaugeForObject(registry, o,
+ "MeanIdleTimeMillis", "mean.idle", tags,
+ "The mean time objects are idle");
+ registerTimeGaugeForObject(registry, o,
+ "MeanBorrowWaitTimeMillis", "mean.borrow.wait", tags,
+ "The mean time threads wait to borrow an object");
+ });
+ }
+ }
+
+ private Iterable nameTag(ObjectName name, String type)
+ throws AttributeNotFoundException, MBeanException, ReflectionException,
+ InstanceNotFoundException {
+ Tags tags = Tags.of("name", name.getKeyProperty("name"), "type", type);
+ if (Objects.equals(type, "GenericObjectPool")) {
+ // for GenericObjectPool, we want to include the name and factoryType as tags
+ String factoryType = mBeanServer.getAttribute(name, "FactoryType").toString();
+ tags = Tags.concat(tags, "factoryType", factoryType);
+ }
+ return tags;
+ }
+
+ private void registerMetricsEventually(String type, BiConsumer perObject) {
+ try {
+ Set objs =
+ mBeanServer.queryNames(new ObjectName(JMX_DOMAIN + ":type=" + type + ",*"), null);
+ for (ObjectName o : objs) {
+ Iterable nameTags = emptyList();
+ try {
+ nameTags = nameTag(o, type);
+ } catch (Exception e) {
+ log.error("exception in determining name tag", e);
+ }
+ perObject.accept(o, Tags.concat(tags, nameTags));
+ }
+ } catch (MalformedObjectNameException e) {
+ throw new RuntimeException("Error registering commons pool2 based metrics", e);
+ }
+
+ registerNotificationListener(type, perObject);
+ }
+
+ /**
+ * This notification listener should remain indefinitely since new pools can be added at
+ * any time.
+ *
+ * @param type The pool type to listen for.
+ * @param perObject Metric registration handler when a new MBean is created.
+ */
+ private void registerNotificationListener(String type, BiConsumer perObject) {
+ NotificationListener notificationListener =
+ // in notification listener, we cannot get attributes for the registered object,
+ // so we do it later time in a separate thread.
+ (notification, handback) -> {
+ executor.execute(
+ () -> {
+ MBeanServerNotification mbs = (MBeanServerNotification) notification;
+ ObjectName o = mbs.getMBeanName();
+ Iterable nameTags = emptyList();
+ int maxTries = 3;
+ for (int i = 0; i < maxTries; i++) {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new RuntimeException(e);
+ }
+ try {
+ nameTags = nameTag(o, type);
+ break;
+ } catch (AttributeNotFoundException
+ | MBeanException
+ | ReflectionException
+ | InstanceNotFoundException e) {
+ if (i == maxTries - 1) {
+ log.error("can not set name tag", e);
+ }
+ }
+ }
+ perObject.accept(o, Tags.concat(tags, nameTags));
+ });
+ };
+
+ NotificationFilter filter =
+ (NotificationFilter)
+ notification -> {
+ if (!MBeanServerNotification.REGISTRATION_NOTIFICATION.equals(notification.getType()))
+ return false;
+ ObjectName obj = ((MBeanServerNotification) notification).getMBeanName();
+ return obj.getDomain().equals(JMX_DOMAIN) && obj.getKeyProperty("type").equals(type);
+ };
+
+ try {
+ mBeanServer.addNotificationListener(
+ MBeanServerDelegate.DELEGATE_NAME, notificationListener, filter, null);
+ notificationListenerCleanUpRunnables.add(
+ () -> {
+ try {
+ mBeanServer.removeNotificationListener(
+ MBeanServerDelegate.DELEGATE_NAME, notificationListener);
+ } catch (InstanceNotFoundException | ListenerNotFoundException ignore) {
+ }
+ });
+ } catch (InstanceNotFoundException ignore) {
+ // unable to register MBean listener
+ }
+ }
+
+ @Override
+ public void close() {
+ notificationListenerCleanUpRunnables.forEach(Runnable::run);
+ executor.shutdown();
+ }
+
+ private void registerGaugeForObject(
+ MeterRegistry registry,
+ ObjectName o,
+ String jmxMetricName,
+ String meterName,
+ Tags allTags,
+ String description,
+ @Nullable String baseUnit) {
+ final AtomicReference gauge = new AtomicReference<>();
+ gauge.set(Gauge
+ .builder(
+ METRIC_NAME_PREFIX + meterName,
+ mBeanServer,
+ getJmxAttribute(registry, gauge, o, jmxMetricName)
+ )
+ .description(description)
+ .baseUnit(baseUnit)
+ .tags(allTags)
+ .register(registry)
+ );
+ }
+
+ private void registerFunctionCounterForObject(MeterRegistry registry, ObjectName o, String jmxMetricName, String meterName, Tags allTags, String description, @Nullable String baseUnit) {
+ final AtomicReference counter = new AtomicReference<>();
+ counter.set(FunctionCounter
+ .builder(
+ METRIC_NAME_PREFIX + meterName,
+ mBeanServer,
+ getJmxAttribute(registry, counter, o, jmxMetricName)
+ )
+ .description(description)
+ .baseUnit(baseUnit)
+ .tags(allTags)
+ .register(registry)
+ );
+ }
+
+ private void registerTimeGaugeForObject(MeterRegistry registry, ObjectName o, String jmxMetricName,
+ String meterName, Tags allTags, String description) {
+ final AtomicReference timeGauge = new AtomicReference<>();
+ timeGauge.set(TimeGauge
+ .builder(
+ METRIC_NAME_PREFIX + meterName,
+ mBeanServer,
+ TimeUnit.MILLISECONDS,
+ getJmxAttribute(registry, timeGauge, o, jmxMetricName)
+ )
+ .description(description)
+ .tags(allTags)
+ .register(registry)
+ );
+ }
+
+ private ToDoubleFunction getJmxAttribute(
+ MeterRegistry registry,
+ AtomicReference meter,
+ ObjectName o,
+ String jmxMetricName) {
+ return s -> safeDouble(
+ () -> {
+ if (!s.isRegistered(o)) {
+ registry.remove(meter.get());
+ }
+ return s.getAttribute(o, jmxMetricName);
+ });
+ }
+
+ private double safeDouble(Callable callable) {
+ try {
+ return Double.parseDouble(callable.call().toString());
+ } catch (Exception e) {
+ return Double.NaN;
+ }
+ }
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/db/DatabaseTableMetrics.java b/micrometer-binders/src/main/java/io/micrometer/binder/db/DatabaseTableMetrics.java
new file mode 100644
index 0000000000..1b63ff4ef0
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/db/DatabaseTableMetrics.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2017 VMware, 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
+ *
+ * https://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 io.micrometer.binder.db;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.function.ToDoubleFunction;
+
+import javax.sql.DataSource;
+
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.binder.BaseUnits;
+import io.micrometer.core.instrument.binder.MeterBinder;
+import io.micrometer.core.lang.NonNullApi;
+import io.micrometer.core.lang.NonNullFields;
+
+/**
+ * @author Jon Schneider
+ */
+@NonNullApi
+@NonNullFields
+public class DatabaseTableMetrics implements MeterBinder {
+ private final DataSource dataSource;
+ private final String query;
+ private final String dataSourceName;
+ private final String tableName;
+ private final Iterable tags;
+
+ /**
+ * Record the row count for an individual database table.
+ *
+ * @param dataSource The data source to use to run the row count query.
+ * @param dataSourceName Will be used to tag metrics with "db".
+ * @param tableName The name of the table to report table size for.
+ * @param tags Tags to apply to all recorded metrics.
+ */
+ public DatabaseTableMetrics(DataSource dataSource, String dataSourceName, String tableName, Iterable tags) {
+ this(dataSource, "SELECT COUNT(1) FROM " + tableName, dataSourceName, tableName, tags);
+ }
+
+ /**
+ * Record the result based on a query.
+ *
+ * @param dataSource The data source to use to run the row count query.
+ * @param query The query to be run against the table. The first column of the result will be the metric and
+ * it should return a single row.
+ * @param dataSourceName The name prefix of the metrics.
+ * @param tableName The name of the table to report table size for.
+ * @param tags Tags to apply to all recorded metrics.
+ */
+ public DatabaseTableMetrics(DataSource dataSource, String query, String dataSourceName, String tableName, Iterable tags) {
+ this.dataSource = dataSource;
+ this.query = query;
+ this.dataSourceName = dataSourceName;
+ this.tableName = tableName;
+ this.tags = tags;
+ }
+
+ /**
+ * Record the row count for an individual database table.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param tableName The name of the table to report table size for.
+ * @param dataSourceName Will be used to tag metrics with "db".
+ * @param dataSource The data source to use to run the row count query.
+ * @param tags Tags to apply to all recorded metrics. Must be an even number of arguments representing key/value pairs of tags.
+ */
+ public static void monitor(MeterRegistry registry, String tableName, String dataSourceName, DataSource dataSource, String... tags) {
+ monitor(registry, dataSource, dataSourceName, tableName, Tags.of(tags));
+ }
+
+ /**
+ * Record the row count for an individual database table.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param dataSource The data source to use to run the row count query.
+ * @param dataSourceName The name prefix of the metrics.
+ * @param tableName The name of the table to report table size for.
+ * @param tags Tags to apply to all recorded metrics.
+ */
+ public static void monitor(MeterRegistry registry, DataSource dataSource, String dataSourceName, String tableName, Iterable tags) {
+ new DatabaseTableMetrics(dataSource, dataSourceName, tableName, tags).bindTo(registry);
+ }
+
+ @Override
+ public void bindTo(MeterRegistry registry) {
+ ToDoubleFunction totalRows = ds -> {
+ try (Connection conn = ds.getConnection();
+ PreparedStatement ps = conn.prepareStatement(query);
+ ResultSet rs = ps.executeQuery()) {
+ rs.next();
+ return rs.getInt(1);
+ } catch (SQLException ignored) {
+ return 0;
+ }
+ };
+
+ Gauge.builder("db.table.size", dataSource, totalRows)
+ .tags(tags)
+ .tag("db", dataSourceName)
+ .tag("table", tableName)
+ .description("Number of rows in a database table")
+ .baseUnit(BaseUnits.ROWS)
+ .register(registry);
+ }
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/db/JooqExecuteListener.java b/micrometer-binders/src/main/java/io/micrometer/binder/db/JooqExecuteListener.java
new file mode 100644
index 0000000000..6c138bbb2b
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/db/JooqExecuteListener.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2020 VMware, 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
+ *
+ * https://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 io.micrometer.binder.db;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Timer;
+import io.micrometer.core.instrument.util.StringUtils;
+import org.jooq.ExecuteContext;
+import org.jooq.exception.DataAccessException;
+import org.jooq.impl.DefaultExecuteListener;
+
+class JooqExecuteListener extends DefaultExecuteListener {
+ private final MeterRegistry registry;
+ private final Iterable tags;
+ private final Supplier> queryTagsSupplier;
+
+ private final Object sampleLock = new Object();
+ private final Map sampleByExecuteContext = new HashMap<>();
+
+ public JooqExecuteListener(MeterRegistry registry, Iterable tags, Supplier> queryTags) {
+ this.registry = registry;
+ this.tags = tags;
+ this.queryTagsSupplier = queryTags;
+ }
+
+ @Override
+ public void start(ExecuteContext ctx) {
+ startTimer(ctx);
+ }
+
+ @Override
+ public void executeStart(ExecuteContext ctx) {
+ startTimer(ctx);
+ }
+
+ private void startTimer(ExecuteContext ctx) {
+ Timer.Sample started = Timer.start(registry);
+ synchronized (sampleLock) {
+ sampleByExecuteContext.put(ctx, started);
+ }
+ }
+
+ @Override
+ public void executeEnd(ExecuteContext ctx) {
+ stopTimerIfStillRunning(ctx);
+ }
+
+ @Override
+ public void end(ExecuteContext ctx) {
+ stopTimerIfStillRunning(ctx);
+ }
+
+ private void stopTimerIfStillRunning(ExecuteContext ctx) {
+ Iterable queryTags = queryTagsSupplier.get();
+ if (queryTags == null) return;
+
+ Timer.Sample sample;
+ synchronized (sampleLock) {
+ sample = sampleByExecuteContext.remove(ctx);
+ }
+ if (sample == null) return;
+
+ String exceptionName = "none";
+ String exceptionSubclass = "none";
+
+ Exception exception = ctx.exception();
+ if (exception != null) {
+ if (exception instanceof DataAccessException) {
+ DataAccessException dae = (DataAccessException) exception;
+ exceptionName = dae.sqlStateClass().name().toLowerCase().replace('_', ' ');
+ exceptionSubclass = dae.sqlStateSubclass().name().toLowerCase().replace('_', ' ');
+ if (exceptionSubclass.contains("no subclass")) {
+ exceptionSubclass = "none";
+ }
+ } else {
+ String simpleName = exception.getClass().getSimpleName();
+ exceptionName = StringUtils.isNotBlank(simpleName) ? simpleName : exception.getClass().getName();
+ }
+ }
+
+ //noinspection unchecked
+ sample.stop(Timer.builder("jooq.query")
+ .description("Execution time of a SQL query performed with JOOQ")
+ .tags(queryTags)
+ .tag("type", ctx.type().name().toLowerCase())
+ .tag("exception", exceptionName)
+ .tag("exception.subclass", exceptionSubclass)
+ .tags(tags)
+ .register(registry));
+ }
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/db/MetricsDSLContext.java b/micrometer-binders/src/main/java/io/micrometer/binder/db/MetricsDSLContext.java
new file mode 100644
index 0000000000..a9be6cd09e
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/db/MetricsDSLContext.java
@@ -0,0 +1,4221 @@
+/*
+ * Copyright 2020 VMware, 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
+ *
+ * https://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 io.micrometer.binder.db;
+
+import java.math.BigInteger;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executor;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import javax.sql.DataSource;
+
+import io.micrometer.core.annotation.Incubating;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import org.jooq.Record;
+import org.jooq.*;
+import org.jooq.conf.Settings;
+import org.jooq.exception.ConfigurationException;
+import org.jooq.exception.DataAccessException;
+import org.jooq.exception.InvalidResultException;
+import org.jooq.exception.NoDataFoundException;
+import org.jooq.exception.TooManyRowsException;
+import org.jooq.impl.DSL;
+import org.jooq.tools.jdbc.MockCallable;
+import org.jooq.tools.jdbc.MockDataProvider;
+import org.jooq.tools.jdbc.MockRunnable;
+import org.jooq.util.xml.jaxb.InformationSchema;
+
+/**
+ * Time SQL queries passing through jOOQ.
+ *
+ * Timing of batch operations and with statements not supported.
+ *
+ * This can be used as the regular jOOQ {@link DSLContext} but queries will be timed
+ * and tags can be set for the query timed. For example:
+ *
+ *
+ * MetricsDSLContext jooq = MetricsDSLContext.withMetrics(DSL.using(configuration), meterRegistry, Tags.empty());
+ * jooq.tag("name", "selectAllAuthors").select(asterisk()).from("author").fetch();
+ *
+ *
+ *
+ * This requires jOOQ 3.14.0 or later.
+ *
+ * @author Jon Schneider
+ * @author Johnny Lim
+ * @since 1.4.0
+ */
+@Incubating(since = "1.4.0")
+public class MetricsDSLContext implements DSLContext {
+ private final DSLContext context;
+ private final MeterRegistry registry;
+ private final Iterable tags;
+ private final ThreadLocal> contextTags = new ThreadLocal<>();
+
+ private final ExecuteListenerProvider defaultExecuteListenerProvider;
+
+ public static MetricsDSLContext withMetrics(DSLContext jooq, MeterRegistry registry, Iterable tags) {
+ return new MetricsDSLContext(jooq, registry, tags);
+ }
+
+ MetricsDSLContext(DSLContext context, MeterRegistry registry, Iterable tags) {
+ this.registry = registry;
+ this.tags = tags;
+
+ this.defaultExecuteListenerProvider = () -> new JooqExecuteListener(registry, tags, () -> {
+ Iterable queryTags = contextTags.get();
+ contextTags.remove();
+ return queryTags;
+ });
+ Configuration configuration = context.configuration().derive();
+ Configuration derivedConfiguration = derive(configuration, this.defaultExecuteListenerProvider);
+
+ this.context = DSL.using(derivedConfiguration);
+ }
+
+ public Q time(Q q) {
+ q.attach(time(q.configuration()));
+ return q;
+ }
+
+ public Configuration time(Configuration c) {
+ Iterable queryTags = contextTags.get();
+ contextTags.remove();
+ return derive(c, () -> new JooqExecuteListener(registry, tags, () -> queryTags));
+ }
+
+ private Configuration derive(Configuration configuration, ExecuteListenerProvider executeListenerProvider) {
+ ExecuteListenerProvider[] providers = configuration.executeListenerProviders();
+ for (int i = 0; i < providers.length; i++) {
+ if (providers[i] == this.defaultExecuteListenerProvider) {
+ ExecuteListenerProvider[] newProviders = Arrays.copyOf(providers, providers.length);
+ newProviders[i] = executeListenerProvider;
+ return configuration.derive(newProviders);
+ }
+ }
+ ExecuteListenerProvider[] newProviders = Arrays.copyOf(providers, providers.length + 1);
+ newProviders[providers.length] = executeListenerProvider;
+ return configuration.derive(newProviders);
+ }
+
+ @SuppressWarnings("unchecked")
+ public O timeCoercable(Object o) {
+ return (O) time((Query) o);
+ }
+
+ public DSLContext tag(String key, String name) {
+ return tags(Tags.of(key, name));
+ }
+
+ public DSLContext tag(Tag tag) {
+ return tags(Tags.of(tag));
+ }
+
+ public DSLContext tags(Iterable tags) {
+ contextTags.set(tags);
+ return this;
+ }
+
+ @Override
+ public Schema map(Schema schema) {
+ return context.map(schema);
+ }
+
+ @Override
+ public Table map(Table table) {
+ return context.map(table);
+ }
+
+ @Override
+ public Parser parser() {
+ return context.parser();
+ }
+
+ @Override
+ public Connection parsingConnection() {
+ return context.parsingConnection();
+ }
+
+ @Override
+ public DataSource parsingDataSource() {
+ return context.parsingDataSource();
+ }
+
+ @Override
+ public Connection diagnosticsConnection() {
+ return context.diagnosticsConnection();
+ }
+
+ @Override
+ public DataSource diagnosticsDataSource() {
+ return context.diagnosticsDataSource();
+ }
+
+ @Override
+ public Version version(String id) {
+ return context.version(id);
+ }
+
+ @Override
+ public Migration migrateTo(Version to) {
+ return context.migrateTo(to);
+ }
+
+ @Override
+ public Meta meta() {
+ return context.meta();
+ }
+
+ @Override
+ public Meta meta(DatabaseMetaData meta) {
+ return context.meta(meta);
+ }
+
+ @Override
+ public Meta meta(Catalog... catalogs) {
+ return context.meta(catalogs);
+ }
+
+ @Override
+ public Meta meta(Schema... schemas) {
+ return context.meta(schemas);
+ }
+
+ @Override
+ public Meta meta(Table... tables) {
+ return context.meta(tables);
+ }
+
+ @Override
+ public Meta meta(InformationSchema schema) {
+ return context.meta(schema);
+ }
+
+ @Override
+ public Meta meta(String... sources) {
+ return context.meta(sources);
+ }
+
+ @Override
+ @Internal
+ public Meta meta(Source... scripts) {
+ return context.meta(scripts);
+ }
+
+ @Override
+ public Meta meta(Query... queries) {
+ return context.meta(queries);
+ }
+
+ @Override
+ public InformationSchema informationSchema(Catalog catalog) {
+ return context.informationSchema(catalog);
+ }
+
+ @Override
+ public InformationSchema informationSchema(Catalog... catalogs) {
+ return context.informationSchema(catalogs);
+ }
+
+ @Override
+ public InformationSchema informationSchema(Schema schema) {
+ return context.informationSchema(schema);
+ }
+
+ @Override
+ public InformationSchema informationSchema(Schema... schemas) {
+ return context.informationSchema(schemas);
+ }
+
+ @Override
+ public InformationSchema informationSchema(Table table) {
+ return context.informationSchema(table);
+ }
+
+ @Override
+ public InformationSchema informationSchema(Table... table) {
+ return context.informationSchema(table);
+ }
+
+ @Override
+ public Explain explain(Query query) {
+ return context.explain(query);
+ }
+
+ @Override
+ public T transactionResult(TransactionalCallable transactional) {
+ return context.transactionResult(transactional);
+ }
+
+ @Override
+ public T transactionResult(ContextTransactionalCallable transactional) throws ConfigurationException {
+ return context.transactionResult(transactional);
+ }
+
+ @Override
+ public void transaction(TransactionalRunnable transactional) {
+ context.transaction(transactional);
+ }
+
+ @Override
+ public void transaction(ContextTransactionalRunnable transactional) throws ConfigurationException {
+ context.transaction(transactional);
+ }
+
+ @Override
+ public CompletionStage transactionResultAsync(TransactionalCallable transactional) throws ConfigurationException {
+ return context.transactionResultAsync(transactional);
+ }
+
+ @Override
+ public CompletionStage transactionAsync(TransactionalRunnable transactional) throws ConfigurationException {
+ return context.transactionAsync(transactional);
+ }
+
+ @Override
+ public CompletionStage transactionResultAsync(Executor executor, TransactionalCallable transactional) throws ConfigurationException {
+ return context.transactionResultAsync(executor, transactional);
+ }
+
+ @Override
+ public CompletionStage transactionAsync(Executor executor, TransactionalRunnable transactional) throws ConfigurationException {
+ return context.transactionAsync(executor, transactional);
+ }
+
+ @Override
+ public T connectionResult(ConnectionCallable callable) {
+ return context.connectionResult(callable);
+ }
+
+ @Override
+ public void connection(ConnectionRunnable runnable) {
+ context.connection(runnable);
+ }
+
+ @Override
+ public T mockResult(MockDataProvider provider, MockCallable mockable) {
+ return context.mockResult(provider, mockable);
+ }
+
+ @Override
+ public void mock(MockDataProvider provider, MockRunnable mockable) {
+ context.mock(provider, mockable);
+ }
+
+ @Override
+ @Internal
+ @Deprecated
+ public RenderContext renderContext() {
+ return context.renderContext();
+ }
+
+ @Override
+ public String render(QueryPart part) {
+ return context.render(part);
+ }
+
+ @Override
+ public String renderNamedParams(QueryPart part) {
+ return context.renderNamedParams(part);
+ }
+
+ @Override
+ public String renderNamedOrInlinedParams(QueryPart part) {
+ return context.renderNamedOrInlinedParams(part);
+ }
+
+ @Override
+ public String renderInlined(QueryPart part) {
+ return context.renderInlined(part);
+ }
+
+ @Override
+ public List extractBindValues(QueryPart part) {
+ return context.extractBindValues(part);
+ }
+
+ @Override
+ public Map> extractParams(QueryPart part) {
+ return context.extractParams(part);
+ }
+
+ @Override
+ public Param extractParam(QueryPart part, String name) {
+ return context.extractParam(part, name);
+ }
+
+ @Override
+ @Internal
+ @Deprecated
+ public BindContext bindContext(PreparedStatement stmt) {
+ return context.bindContext(stmt);
+ }
+
+ @Override
+ @Deprecated
+ public int bind(QueryPart part, PreparedStatement stmt) {
+ return context.bind(part, stmt);
+ }
+
+ @Override
+ public void attach(Attachable... attachables) {
+ context.attach(attachables);
+ }
+
+ @Override
+ public void attach(Collection attachables) {
+ context.attach(attachables);
+ }
+
+ @Override
+ public LoaderOptionsStep loadInto(Table table) {
+ return context.loadInto(table);
+ }
+
+ @Override
+ public Queries queries(Query... queries) {
+ return context.queries(queries);
+ }
+
+ @Override
+ public Queries queries(Collection queries) {
+ return context.queries(queries);
+ }
+
+ @Override
+ public Block begin(Statement... statements) {
+ return context.begin(statements);
+ }
+
+ @Override
+ public Block begin(Collection statements) {
+ return context.begin(statements);
+ }
+
+ @Override
+ public RowCountQuery query(SQL sql) {
+ return context.query(sql);
+ }
+
+ @Override
+ public RowCountQuery query(String sql) {
+ return context.query(sql);
+ }
+
+ @Override
+ public RowCountQuery query(String sql, Object... bindings) {
+ return context.query(sql, bindings);
+ }
+
+ @Override
+ public RowCountQuery query(String sql, QueryPart... parts) {
+ return context.query(sql, parts);
+ }
+
+ @Override
+ public Result fetch(SQL sql) throws DataAccessException {
+ return context.fetch(sql);
+ }
+
+ @Override
+ public Result fetch(String sql) throws DataAccessException {
+ return context.fetch(sql);
+ }
+
+ @Override
+ public Result fetch(String sql, Object... bindings) throws DataAccessException {
+ return context.fetch(sql, bindings);
+ }
+
+ @Override
+ public Result fetch(String sql, QueryPart... parts) throws DataAccessException {
+ return context.fetch(sql, parts);
+ }
+
+ @Override
+ public Cursor fetchLazy(SQL sql) throws DataAccessException {
+ return context.fetchLazy(sql);
+ }
+
+ @Override
+ public Cursor fetchLazy(String sql) throws DataAccessException {
+ return context.fetchLazy(sql);
+ }
+
+ @Override
+ public Cursor fetchLazy(String sql, Object... bindings) throws DataAccessException {
+ return context.fetchLazy(sql, bindings);
+ }
+
+ @Override
+ public Cursor fetchLazy(String sql, QueryPart... parts) throws DataAccessException {
+ return context.fetchLazy(sql, parts);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(SQL sql) {
+ return context.fetchAsync(sql);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(String sql) {
+ return context.fetchAsync(sql);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(String sql, Object... bindings) {
+ return context.fetchAsync(sql, bindings);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(String sql, QueryPart... parts) {
+ return context.fetchAsync(sql, parts);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(Executor executor, SQL sql) {
+ return context.fetchAsync(executor, sql);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(Executor executor, String sql) {
+ return context.fetchAsync(executor, sql);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(Executor executor, String sql, Object... bindings) {
+ return context.fetchAsync(executor, sql, bindings);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(Executor executor, String sql, QueryPart... parts) {
+ return context.fetchAsync(executor, sql, parts);
+ }
+
+ @Override
+ public Stream fetchStream(SQL sql) throws DataAccessException {
+ return context.fetchStream(sql);
+ }
+
+ @Override
+ public Stream fetchStream(String sql) throws DataAccessException {
+ return context.fetchStream(sql);
+ }
+
+ @Override
+ public Stream fetchStream(String sql, Object... bindings) throws DataAccessException {
+ return context.fetchStream(sql, bindings);
+ }
+
+ @Override
+ public Stream fetchStream(String sql, QueryPart... parts) throws DataAccessException {
+ return context.fetchStream(sql, parts);
+ }
+
+ @Override
+ public Results fetchMany(SQL sql) throws DataAccessException {
+ return context.fetchMany(sql);
+ }
+
+ @Override
+ public Results fetchMany(String sql) throws DataAccessException {
+ return context.fetchMany(sql);
+ }
+
+ @Override
+ public Results fetchMany(String sql, Object... bindings) throws DataAccessException {
+ return context.fetchMany(sql, bindings);
+ }
+
+ @Override
+ public Results fetchMany(String sql, QueryPart... parts) throws DataAccessException {
+ return context.fetchMany(sql, parts);
+ }
+
+ @Override
+ public Record fetchOne(SQL sql) throws DataAccessException, TooManyRowsException {
+ return context.fetchOne(sql);
+ }
+
+ @Override
+ public Record fetchOne(String sql) throws DataAccessException, TooManyRowsException {
+ return context.fetchOne(sql);
+ }
+
+ @Override
+ public Record fetchOne(String sql, Object... bindings) throws DataAccessException, TooManyRowsException {
+ return context.fetchOne(sql, bindings);
+ }
+
+ @Override
+ public Record fetchOne(String sql, QueryPart... parts) throws DataAccessException, TooManyRowsException {
+ return context.fetchOne(sql, parts);
+ }
+
+ @Override
+ public Record fetchSingle(SQL sql) throws DataAccessException, NoDataFoundException, TooManyRowsException {
+ return context.fetchSingle(sql);
+ }
+
+ @Override
+ public Record fetchSingle(String sql) throws DataAccessException, NoDataFoundException, TooManyRowsException {
+ return context.fetchSingle(sql);
+ }
+
+ @Override
+ public Record fetchSingle(String sql, Object... bindings) throws DataAccessException, NoDataFoundException, TooManyRowsException {
+ return context.fetchSingle(sql, bindings);
+ }
+
+ @Override
+ public Record fetchSingle(String sql, QueryPart... parts) throws DataAccessException, NoDataFoundException, TooManyRowsException {
+ return context.fetchSingle(sql, parts);
+ }
+
+ @Override
+ public Optional fetchOptional(SQL sql) throws DataAccessException, TooManyRowsException {
+ return context.fetchOptional(sql);
+ }
+
+ @Override
+ public Optional fetchOptional(String sql) throws DataAccessException, TooManyRowsException {
+ return context.fetchOptional(sql);
+ }
+
+ @Override
+ public Optional fetchOptional(String sql, Object... bindings) throws DataAccessException, TooManyRowsException {
+ return context.fetchOptional(sql, bindings);
+ }
+
+ @Override
+ public Optional fetchOptional(String sql, QueryPart... parts) throws DataAccessException, TooManyRowsException {
+ return context.fetchOptional(sql, parts);
+ }
+
+ @Override
+ public Object fetchValue(SQL sql) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchValue(sql);
+ }
+
+ @Override
+ public Object fetchValue(String sql) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchValue(sql);
+ }
+
+ @Override
+ public Object fetchValue(String sql, Object... bindings) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchValue(sql, bindings);
+ }
+
+ @Override
+ public Object fetchValue(String sql, QueryPart... parts) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchValue(sql, parts);
+ }
+
+ @Override
+ public Optional fetchOptionalValue(SQL sql) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchOptionalValue(sql);
+ }
+
+ @Override
+ public Optional fetchOptionalValue(String sql) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchOptionalValue(sql);
+ }
+
+ @Override
+ public Optional fetchOptionalValue(String sql, Object... bindings) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchOptionalValue(sql, bindings);
+ }
+
+ @Override
+ public Optional fetchOptionalValue(String sql, QueryPart... parts) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchOptionalValue(sql, parts);
+ }
+
+ @Override
+ public List fetchValues(SQL sql) throws DataAccessException, InvalidResultException {
+ return context.fetchValues(sql);
+ }
+
+ @Override
+ public List fetchValues(String sql) throws DataAccessException, InvalidResultException {
+ return context.fetchValues(sql);
+ }
+
+ @Override
+ public List fetchValues(String sql, Object... bindings) throws DataAccessException, InvalidResultException {
+ return context.fetchValues(sql, bindings);
+ }
+
+ @Override
+ public List fetchValues(String sql, QueryPart... parts) throws DataAccessException, InvalidResultException {
+ return context.fetchValues(sql, parts);
+ }
+
+ @Override
+ public int execute(SQL sql) throws DataAccessException {
+ return context.execute(sql);
+ }
+
+ @Override
+ public int execute(String sql) throws DataAccessException {
+ return context.execute(sql);
+ }
+
+ @Override
+ public int execute(String sql, Object... bindings) throws DataAccessException {
+ return context.execute(sql, bindings);
+ }
+
+ @Override
+ public int execute(String sql, QueryPart... parts) throws DataAccessException {
+ return context.execute(sql, parts);
+ }
+
+ @Override
+ public ResultQuery resultQuery(SQL sql) {
+ return context.resultQuery(sql);
+ }
+
+ @Override
+ public ResultQuery resultQuery(String sql) {
+ return context.resultQuery(sql);
+ }
+
+ @Override
+ public ResultQuery resultQuery(String sql, Object... bindings) {
+ return context.resultQuery(sql, bindings);
+ }
+
+ @Override
+ public ResultQuery resultQuery(String sql, QueryPart... parts) {
+ return context.resultQuery(sql, parts);
+ }
+
+ @Override
+ public Result fetch(ResultSet rs) throws DataAccessException {
+ return context.fetch(rs);
+ }
+
+ @Override
+ public Result fetch(ResultSet rs, Field... fields) throws DataAccessException {
+ return context.fetch(rs, fields);
+ }
+
+ @Override
+ public Result fetch(ResultSet rs, DataType... types) throws DataAccessException {
+ return context.fetch(rs, types);
+ }
+
+ @Override
+ public Result fetch(ResultSet rs, Class... types) throws DataAccessException {
+ return context.fetch(rs, types);
+ }
+
+ @Override
+ public Record fetchOne(ResultSet rs) throws DataAccessException, TooManyRowsException {
+ return context.fetchOne(rs);
+ }
+
+ @Override
+ public Record fetchOne(ResultSet rs, Field... fields) throws DataAccessException, TooManyRowsException {
+ return context.fetchOne(rs, fields);
+ }
+
+ @Override
+ public Record fetchOne(ResultSet rs, DataType... types) throws DataAccessException, TooManyRowsException {
+ return context.fetchOne(rs, types);
+ }
+
+ @Override
+ public Record fetchOne(ResultSet rs, Class... types) throws DataAccessException, TooManyRowsException {
+ return context.fetchOne(rs, types);
+ }
+
+ @Override
+ public Record fetchSingle(ResultSet rs) throws DataAccessException, TooManyRowsException {
+ return context.fetchSingle(rs);
+ }
+
+ @Override
+ public Record fetchSingle(ResultSet rs, Field... fields) throws DataAccessException, NoDataFoundException, TooManyRowsException {
+ return context.fetchSingle(rs, fields);
+ }
+
+ @Override
+ public Record fetchSingle(ResultSet rs, DataType... types) throws DataAccessException, NoDataFoundException, TooManyRowsException {
+ return context.fetchSingle(rs, types);
+ }
+
+ @Override
+ public Record fetchSingle(ResultSet rs, Class... types) throws DataAccessException, NoDataFoundException, TooManyRowsException {
+ return context.fetchSingle(rs, types);
+ }
+
+ @Override
+ public Optional fetchOptional(ResultSet rs) throws DataAccessException, NoDataFoundException, TooManyRowsException {
+ return context.fetchOptional(rs);
+ }
+
+ @Override
+ public Optional fetchOptional(ResultSet rs, Field... fields) throws DataAccessException, TooManyRowsException {
+ return context.fetchOptional(rs, fields);
+ }
+
+ @Override
+ public Optional fetchOptional(ResultSet rs, DataType... types) throws DataAccessException, TooManyRowsException {
+ return context.fetchOptional(rs, types);
+ }
+
+ @Override
+ public Optional fetchOptional(ResultSet rs, Class... types) throws DataAccessException, TooManyRowsException {
+ return context.fetchOptional(rs, types);
+ }
+
+ @Override
+ public Object fetchValue(ResultSet rs) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchValue(rs);
+ }
+
+ @Override
+ public T fetchValue(ResultSet rs, Field field) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchValue(rs, field);
+ }
+
+ @Override
+ public T fetchValue(ResultSet rs, DataType type) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchValue(rs, type);
+ }
+
+ @Override
+ public T fetchValue(ResultSet rs, Class type) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchValue(rs, type);
+ }
+
+ @Override
+ public Optional fetchOptionalValue(ResultSet rs) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchOptionalValue(rs);
+ }
+
+ @Override
+ public Optional fetchOptionalValue(ResultSet rs, Field field) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchOptionalValue(rs, field);
+ }
+
+ @Override
+ public Optional fetchOptionalValue(ResultSet rs, DataType type) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchOptionalValue(rs, type);
+ }
+
+ @Override
+ public Optional fetchOptionalValue(ResultSet rs, Class type) throws DataAccessException, TooManyRowsException, InvalidResultException {
+ return context.fetchOptionalValue(rs, type);
+ }
+
+ @Override
+ public List fetchValues(ResultSet rs) throws DataAccessException, InvalidResultException {
+ return context.fetchValues(rs);
+ }
+
+ @Override
+ public List fetchValues(ResultSet rs, Field field) throws DataAccessException, InvalidResultException {
+ return context.fetchValues(rs, field);
+ }
+
+ @Override
+ public List fetchValues(ResultSet rs, DataType type) throws DataAccessException, InvalidResultException {
+ return context.fetchValues(rs, type);
+ }
+
+ @Override
+ public List fetchValues(ResultSet rs, Class type) throws DataAccessException, InvalidResultException {
+ return context.fetchValues(rs, type);
+ }
+
+ @Override
+ public Cursor fetchLazy(ResultSet rs) throws DataAccessException {
+ return context.fetchLazy(rs);
+ }
+
+ @Override
+ public Cursor fetchLazy(ResultSet rs, Field... fields) throws DataAccessException {
+ return context.fetchLazy(rs, fields);
+ }
+
+ @Override
+ public Cursor fetchLazy(ResultSet rs, DataType... types) throws DataAccessException {
+ return context.fetchLazy(rs, types);
+ }
+
+ @Override
+ public Cursor fetchLazy(ResultSet rs, Class... types) throws DataAccessException {
+ return context.fetchLazy(rs, types);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(ResultSet rs) {
+ return context.fetchAsync(rs);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(ResultSet rs, Field... fields) {
+ return context.fetchAsync(rs, fields);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(ResultSet rs, DataType... types) {
+ return context.fetchAsync(rs, types);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(ResultSet rs, Class... types) {
+ return context.fetchAsync(rs, types);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(Executor executor, ResultSet rs) {
+ return context.fetchAsync(executor, rs);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(Executor executor, ResultSet rs, Field... fields) {
+ return context.fetchAsync(executor, rs, fields);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(Executor executor, ResultSet rs, DataType... types) {
+ return context.fetchAsync(executor, rs, types);
+ }
+
+ @Override
+ public CompletionStage> fetchAsync(Executor executor, ResultSet rs, Class... types) {
+ return context.fetchAsync(executor, rs, types);
+ }
+
+ @Override
+ public Stream fetchStream(ResultSet rs) throws DataAccessException {
+ return context.fetchStream(rs);
+ }
+
+ @Override
+ public Stream fetchStream(ResultSet rs, Field... fields) throws DataAccessException {
+ return context.fetchStream(rs, fields);
+ }
+
+ @Override
+ public Stream fetchStream(ResultSet rs, DataType... types) throws DataAccessException {
+ return context.fetchStream(rs, types);
+ }
+
+ @Override
+ public Stream fetchStream(ResultSet rs, Class... types) throws DataAccessException {
+ return context.fetchStream(rs, types);
+ }
+
+ @Override
+ public Result fetchFromTXT(String string) throws DataAccessException {
+ return context.fetchFromTXT(string);
+ }
+
+ @Override
+ public Result fetchFromTXT(String string, String nullLiteral) throws DataAccessException {
+ return context.fetchFromTXT(string, nullLiteral);
+ }
+
+ @Override
+ public Result fetchFromHTML(String string) throws DataAccessException {
+ return context.fetchFromHTML(string);
+ }
+
+ @Override
+ public Result fetchFromCSV(String string) throws DataAccessException {
+ return context.fetchFromCSV(string);
+ }
+
+ @Override
+ public Result fetchFromCSV(String string, char delimiter) throws DataAccessException {
+ return context.fetchFromCSV(string, delimiter);
+ }
+
+ @Override
+ public Result fetchFromCSV(String string, boolean header) throws DataAccessException {
+ return context.fetchFromCSV(string, header);
+ }
+
+ @Override
+ public Result fetchFromCSV(String string, boolean header, char delimiter) throws DataAccessException {
+ return context.fetchFromCSV(string, header, delimiter);
+ }
+
+ @Override
+ public Result fetchFromJSON(String string) {
+ return context.fetchFromJSON(string);
+ }
+
+ @Override
+ public Result fetchFromXML(String string) {
+ return context.fetchFromXML(string);
+ }
+
+ @Override
+ public Result fetchFromStringData(String[]... data) {
+ return context.fetchFromStringData(data);
+ }
+
+ @Override
+ public Result fetchFromStringData(List data) {
+ return context.fetchFromStringData(data);
+ }
+
+ @Override
+ public Result fetchFromStringData(List data, boolean header) {
+ return context.fetchFromStringData(data, header);
+ }
+
+ @Override
+ public WithAsStep with(String alias) {
+ return context.with(alias);
+ }
+
+ @Override
+ public WithAsStep with(String alias, String... fieldAliases) {
+ return context.with(alias, fieldAliases);
+ }
+
+ @Override
+ public WithAsStep with(String alias, Collection fieldAliases) {
+ return context.with(alias, fieldAliases);
+ }
+
+ @Override
+ public WithAsStep with(Name alias) {
+ return context.with(alias);
+ }
+
+ @Override
+ public WithAsStep with(Name alias, Name... fieldAliases) {
+ return context.with(alias, fieldAliases);
+ }
+
+ @Override
+ public WithAsStep with(Name alias, Collection fieldAliases) {
+ return context.with(alias, fieldAliases);
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public WithAsStep with(String alias, Function, ? extends String> fieldNameFunction) {
+ return context.with(alias, fieldNameFunction);
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public WithAsStep with(String alias, BiFunction, ? super Integer, ? extends String> fieldNameFunction) {
+ return context.with(alias, fieldNameFunction);
+ }
+
+ @Override
+ public WithAsStep1 with(String alias, String fieldAlias1) {
+ return context.with(alias, fieldAlias1);
+ }
+
+ @Override
+ public WithAsStep2 with(String alias, String fieldAlias1, String fieldAlias2) {
+ return context.with(alias, fieldAlias1, fieldAlias2);
+ }
+
+ @Override
+ public WithAsStep3 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3);
+ }
+
+ @Override
+ public WithAsStep4 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
+ }
+
+ @Override
+ public WithAsStep5 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
+ }
+
+ @Override
+ public WithAsStep6 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
+ }
+
+ @Override
+ public WithAsStep7 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
+ }
+
+ @Override
+ public WithAsStep8 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
+ }
+
+ @Override
+ public WithAsStep9 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
+ }
+
+ @Override
+ public WithAsStep10 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
+ }
+
+ @Override
+ public WithAsStep11 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
+ }
+
+ @Override
+ public WithAsStep12 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
+ }
+
+ @Override
+ public WithAsStep13 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
+ }
+
+ @Override
+ public WithAsStep14 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
+ }
+
+ @Override
+ public WithAsStep15 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
+ }
+
+ @Override
+ public WithAsStep16 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
+ }
+
+ @Override
+ public WithAsStep17 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
+ }
+
+ @Override
+ public WithAsStep18 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
+ }
+
+ @Override
+ public WithAsStep19 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
+ }
+
+ @Override
+ public WithAsStep20 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
+ }
+
+ @Override
+ public WithAsStep21 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
+ }
+
+ @Override
+ public WithAsStep22 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
+ }
+
+ @Override
+ public WithAsStep1 with(Name alias, Name fieldAlias1) {
+ return context.with(alias, fieldAlias1);
+ }
+
+ @Override
+ public WithAsStep2 with(Name alias, Name fieldAlias1, Name fieldAlias2) {
+ return context.with(alias, fieldAlias1, fieldAlias2);
+ }
+
+ @Override
+ public WithAsStep3 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3);
+ }
+
+ @Override
+ public WithAsStep4 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
+ }
+
+ @Override
+ public WithAsStep5 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
+ }
+
+ @Override
+ public WithAsStep6 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
+ }
+
+ @Override
+ public WithAsStep7 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
+ }
+
+ @Override
+ public WithAsStep8 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
+ }
+
+ @Override
+ public WithAsStep9 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
+ }
+
+ @Override
+ public WithAsStep10 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
+ }
+
+ @Override
+ public WithAsStep11 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
+ }
+
+ @Override
+ public WithAsStep12 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
+ }
+
+ @Override
+ public WithAsStep13 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
+ }
+
+ @Override
+ public WithAsStep14 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
+ }
+
+ @Override
+ public WithAsStep15 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
+ }
+
+ @Override
+ public WithAsStep16 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
+ }
+
+ @Override
+ public WithAsStep17 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
+ }
+
+ @Override
+ public WithAsStep18 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
+ }
+
+ @Override
+ public WithAsStep19 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
+ }
+
+ @Override
+ public WithAsStep20 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
+ }
+
+ @Override
+ public WithAsStep21 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
+ }
+
+ @Override
+ public WithAsStep22 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22) {
+ return context.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
+ }
+
+ @Override
+ public WithStep with(CommonTableExpression... tables) {
+ return context.with(tables);
+ }
+
+ @Override
+ public WithStep with(Collection> tables) {
+ return context.with(tables);
+ }
+
+ @Override
+ public WithAsStep withRecursive(String alias) {
+ return context.withRecursive(alias);
+ }
+
+ @Override
+ public WithAsStep withRecursive(String alias, String... fieldAliases) {
+ return context.withRecursive(alias, fieldAliases);
+ }
+
+ @Override
+ public WithAsStep withRecursive(String alias, Collection fieldAliases) {
+ return context.withRecursive(alias, fieldAliases);
+ }
+
+ @Override
+ public WithAsStep withRecursive(Name alias) {
+ return context.withRecursive(alias);
+ }
+
+ @Override
+ public WithAsStep withRecursive(Name alias, Name... fieldAliases) {
+ return context.withRecursive(alias, fieldAliases);
+ }
+
+ @Override
+ public WithAsStep withRecursive(Name alias, Collection fieldAliases) {
+ return context.withRecursive(alias, fieldAliases);
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public WithAsStep withRecursive(String alias, Function, ? extends String> fieldNameFunction) {
+ return context.withRecursive(alias, fieldNameFunction);
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public WithAsStep withRecursive(String alias, BiFunction, ? super Integer, ? extends String> fieldNameFunction) {
+ return context.withRecursive(alias, fieldNameFunction);
+ }
+
+ @Override
+ public WithAsStep1 withRecursive(String alias, String fieldAlias1) {
+ return context.withRecursive(alias, fieldAlias1);
+ }
+
+ @Override
+ public WithAsStep2 withRecursive(String alias, String fieldAlias1, String fieldAlias2) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2);
+ }
+
+ @Override
+ public WithAsStep3 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3);
+ }
+
+ @Override
+ public WithAsStep4 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
+ }
+
+ @Override
+ public WithAsStep5 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
+ }
+
+ @Override
+ public WithAsStep6 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
+ }
+
+ @Override
+ public WithAsStep7 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
+ }
+
+ @Override
+ public WithAsStep8 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
+ }
+
+ @Override
+ public WithAsStep9 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
+ }
+
+ @Override
+ public WithAsStep10 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
+ }
+
+ @Override
+ public WithAsStep11 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
+ }
+
+ @Override
+ public WithAsStep12 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
+ }
+
+ @Override
+ public WithAsStep13 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
+ }
+
+ @Override
+ public WithAsStep14 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
+ }
+
+ @Override
+ public WithAsStep15 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
+ }
+
+ @Override
+ public WithAsStep16 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
+ }
+
+ @Override
+ public WithAsStep17 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
+ }
+
+ @Override
+ public WithAsStep18 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
+ }
+
+ @Override
+ public WithAsStep19 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
+ }
+
+ @Override
+ public WithAsStep20 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
+ }
+
+ @Override
+ public WithAsStep21 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
+ }
+
+ @Override
+ public WithAsStep22 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
+ }
+
+ @Override
+ public WithAsStep1 withRecursive(Name alias, Name fieldAlias1) {
+ return context.withRecursive(alias, fieldAlias1);
+ }
+
+ @Override
+ public WithAsStep2 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2);
+ }
+
+ @Override
+ public WithAsStep3 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3);
+ }
+
+ @Override
+ public WithAsStep4 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
+ }
+
+ @Override
+ public WithAsStep5 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
+ }
+
+ @Override
+ public WithAsStep6 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
+ }
+
+ @Override
+ public WithAsStep7 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
+ }
+
+ @Override
+ public WithAsStep8 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
+ }
+
+ @Override
+ public WithAsStep9 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
+ }
+
+ @Override
+ public WithAsStep10 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
+ }
+
+ @Override
+ public WithAsStep11 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
+ }
+
+ @Override
+ public WithAsStep12 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
+ }
+
+ @Override
+ public WithAsStep13 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
+ }
+
+ @Override
+ public WithAsStep14 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
+ }
+
+ @Override
+ public WithAsStep15 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
+ }
+
+ @Override
+ public WithAsStep16 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
+ }
+
+ @Override
+ public WithAsStep17 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
+ }
+
+ @Override
+ public WithAsStep18 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
+ }
+
+ @Override
+ public WithAsStep19 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
+ }
+
+ @Override
+ public WithAsStep20 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
+ }
+
+ @Override
+ public WithAsStep21 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
+ }
+
+ @Override
+ public WithAsStep22 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22) {
+ return context.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
+ }
+
+ @Override
+ public WithStep withRecursive(CommonTableExpression... tables) {
+ return context.withRecursive(tables);
+ }
+
+ @Override
+ public WithStep withRecursive(Collection> tables) {
+ return context.withRecursive(tables);
+ }
+
+ @Override
+ public SelectWhereStep selectFrom(Table table) {
+ return time(context.selectFrom(table));
+ }
+
+ @Override
+ public SelectWhereStep selectFrom(Name table) {
+ return time(context.selectFrom(table));
+ }
+
+ @Override
+ public SelectWhereStep selectFrom(SQL sql) {
+ return time(context.selectFrom(sql));
+ }
+
+ @Override
+ public SelectWhereStep selectFrom(String sql) {
+ return time(context.selectFrom(sql));
+ }
+
+ @Override
+ public SelectWhereStep selectFrom(String sql, Object... bindings) {
+ return time(context.selectFrom(sql, bindings));
+ }
+
+ @Override
+ public SelectWhereStep selectFrom(String sql, QueryPart... parts) {
+ return time(context.selectFrom(sql, parts));
+ }
+
+ @Override
+ public SelectSelectStep select(Collection fields) {
+ return time(context.select(fields));
+ }
+
+ @Override
+ public SelectSelectStep select(SelectFieldOrAsterisk... fields) {
+ return time(context.select(fields));
+ }
+
+ @Override
+ public SelectSelectStep> select(SelectField field1) {
+ return time(context.select(field1));
+ }
+
+ @Override
+ public SelectSelectStep> select(SelectField field1, SelectField field2) {
+ return time(context.select(field1, field2));
+ }
+
+ @Override
+ public SelectSelectStep> select(SelectField field1, SelectField field2, SelectField field3) {
+ return time(context.select(field1, field2, field3));
+ }
+
+ @Override
+ public SelectSelectStep> select(SelectField field1, SelectField field2, SelectField field3, SelectField field4) {
+ return time(context.select(field1, field2, field3, field4));
+ }
+
+ @Override
+ public SelectSelectStep> select(SelectField field1, SelectField field2, SelectField