From 45f4809a2777cbbaae1fef260ae5a1992f588fd6 Mon Sep 17 00:00:00 2001 From: Devin Smith Date: Wed, 26 May 2021 19:17:51 -0500 Subject: [PATCH] Fix nightly check (#641) --- .github/env/Linux/gradle.properties | 11 +- .github/workflows/build-ci.yml | 20 +- .github/workflows/check-ci.yml | 5 +- .github/workflows/docs-ci.yml | 10 +- .github/workflows/long-check-ci.yml | 5 +- .github/workflows/nightly-benchmarks.yml | 5 +- .github/workflows/nightly-check-ci.yml | 180 +++++++++++++++++- .../treetable/AbstractTreeSnapshotImpl.java | 10 +- .../treetable/RollupSnapshotImpl.java | 7 +- .../treetable/TreeSnapshotQuery.java | 8 +- .../treetable/TreeTableSnapshotImpl.java | 9 +- .../treetable/TreeSnapshotQueryTest.java | 5 +- .../db/util/TestWorkerPythonEnvironment.java | 2 +- DB/DB.gradle | 10 +- .../tables/utils/TableToolsMergeHelper.java | 5 +- .../db/tables/utils/WindowCheck.java | 12 +- .../io/deephaven/db/v2/AsOfJoinHelper.java | 24 ++- .../java/io/deephaven/db/v2/BaseTable.java | 4 +- .../io/deephaven/db/v2/CrossJoinHelper.java | 19 +- .../io/deephaven/db/v2/MergedListener.java | 7 +- .../io/deephaven/db/v2/NaturalJoinHelper.java | 23 ++- .../java/io/deephaven/db/v2/QueryTable.java | 30 ++- .../db/v2/ReverseLookupListener.java | 3 +- .../io/deephaven/db/v2/ReverseOperation.java | 5 +- .../db/v2/ShiftAwareSwapListener.java | 5 +- .../io/deephaven/db/v2/SortOperation.java | 5 +- .../java/io/deephaven/db/v2/SourceTable.java | 2 +- .../java/io/deephaven/db/v2/SwapListener.java | 5 +- .../io/deephaven/db/v2/SwapListenerBase.java | 6 +- .../io/deephaven/db/v2/TreeTableFilter.java | 31 ++- .../deephaven/db/v2/WouldMatchOperation.java | 21 +- .../join/BucketedChunkedAjMergedListener.java | 6 +- .../join/ZeroKeyChunkedAjMergedListener.java | 6 +- .../snapshot/SnapshotIncrementalListener.java | 5 +- .../db/v2/sources/UnionSourceManager.java | 9 +- .../db/v2/utils/SyncTableFilter.java | 3 +- .../db/tables/utils/TestWindowCheck.java | 5 +- .../java/io/deephaven/db/v2/QueryFactory.java | 4 +- .../io/deephaven/db/v2/QueryTableAjTest.java | 26 +-- .../db/v2/QueryTableCrossJoinTestBase.java | 9 +- .../db/v2/QueryTableNaturalJoinTest.java | 6 +- ...QueryTableStaticNaturalJoinRandomTest.java | 2 +- .../deephaven/db/v2/QueryTableTreeTest.java | 34 ++-- .../db/v2/SelectOverheadLimiter.java | 7 +- .../db/v2/TestConcurrentInstantiation.java | 3 +- .../db/v2/TestSelectOverheadLimiter.java | 24 ++- .../java/io/deephaven/db/v2/fuzzertest.groovy | 3 +- .../example_plots/plotting_samples.groovy | 6 +- gradle.properties | 2 +- .../table/ExportedTableUpdateListener.java | 2 +- 50 files changed, 384 insertions(+), 272 deletions(-) diff --git a/.github/env/Linux/gradle.properties b/.github/env/Linux/gradle.properties index 6f4703579a7..fc0a159fecd 100644 --- a/.github/env/Linux/gradle.properties +++ b/.github/env/Linux/gradle.properties @@ -1,6 +1,13 @@ +# TODO (deephaven-core#639): Customize gradle settings per-CI job +# # https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#supported-runners-and-hardware-resources -org.gradle.parallel=true -org.gradle.workers.max=2 +# GitHub hosted linux runner environment has 2 CPUs and 7G RAM. +# +# testParallel seems to run poorly on GH Actions, and is unable to take advantage it seems of 2 +# workers. Let's bump up max heap, and target it as the lowest-common denominator. + +org.gradle.parallel=false +org.gradle.workers.max=1 org.gradle.jvmargs=-Xmx6g # Our CI JDKs should be pre-provisioned and invoked correctly, diff --git a/.github/workflows/build-ci.yml b/.github/workflows/build-ci.yml index 8fc6c5bf549..529b57003f1 100644 --- a/.github/workflows/build-ci.yml +++ b/.github/workflows/build-ci.yml @@ -68,9 +68,8 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties - name: Create Dockerfile and context uses: burrunan/gradle-cache-action@v1 @@ -134,9 +133,8 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties - name: Create Dockerfile and context uses: burrunan/gradle-cache-action@v1 @@ -194,9 +192,8 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties - name: Create Dockerfile and context uses: burrunan/gradle-cache-action@v1 @@ -260,9 +257,8 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties - name: Create Dockerfile and context uses: burrunan/gradle-cache-action@v1 diff --git a/.github/workflows/check-ci.yml b/.github/workflows/check-ci.yml index be7b9f15029..279e4fb107f 100644 --- a/.github/workflows/check-ci.yml +++ b/.github/workflows/check-ci.yml @@ -23,9 +23,8 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties - name: Check uses: burrunan/gradle-cache-action@v1 diff --git a/.github/workflows/docs-ci.yml b/.github/workflows/docs-ci.yml index 407bd9375d5..2c293d2f70e 100644 --- a/.github/workflows/docs-ci.yml +++ b/.github/workflows/docs-ci.yml @@ -28,9 +28,8 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java-8.outputs.path }},${{ steps.setup-java-11.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java-8.outputs.path }},${{ steps.setup-java-11.outputs.path }}" >> gradle.properties - name: All Javadoc uses: burrunan/gradle-cache-action@v1 @@ -71,9 +70,8 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties - name: Generate Python Docs uses: burrunan/gradle-cache-action@v1 diff --git a/.github/workflows/long-check-ci.yml b/.github/workflows/long-check-ci.yml index 8ad79d7a2ec..e87e5a20401 100644 --- a/.github/workflows/long-check-ci.yml +++ b/.github/workflows/long-check-ci.yml @@ -23,9 +23,8 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties - name: Check uses: burrunan/gradle-cache-action@v1 diff --git a/.github/workflows/nightly-benchmarks.yml b/.github/workflows/nightly-benchmarks.yml index 7982d0e44fb..8023147203b 100644 --- a/.github/workflows/nightly-benchmarks.yml +++ b/.github/workflows/nightly-benchmarks.yml @@ -22,9 +22,8 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties - name: Build uses: burrunan/gradle-cache-action@v1 diff --git a/.github/workflows/nightly-check-ci.yml b/.github/workflows/nightly-check-ci.yml index fb4910b1202..15e78c1e76b 100644 --- a/.github/workflows/nightly-check-ci.yml +++ b/.github/workflows/nightly-check-ci.yml @@ -6,11 +6,12 @@ on: schedule: # 2AM EST == 6AM UTC - cron: '0 6 * * *' + push: + branches: [ 'nightly/**' ] jobs: - nightly: + check: runs-on: ubuntu-20.04 - timeout-minutes: 720 steps: - name: Checkout uses: actions/checkout@v2 @@ -24,24 +25,183 @@ jobs: - name: Setup gradle properties run: | - mkdir -p $HOME/.gradle - cp .github/env/${{ runner.os }}/gradle.properties $HOME/.gradle/gradle.properties - echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> $HOME/.gradle/gradle.properties + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties - - name: Check + - name: Run gradle uses: burrunan/gradle-cache-action@v1 - timeout-minutes: 720 with: - job-id: nightly - arguments: --scan --continue nightly + job-id: check + arguments: --scan --continue --rerun-tasks check gradle-version: wrapper + - name: Upload Test Results + uses: actions/upload-artifact@v2 + if: always() + with: + name: nightly-check-ci-results + path: '**/build/test-results/*/TEST-*.xml' + + - name: Upload Test Reports + uses: actions/upload-artifact@v2 + if: always() + with: + name: nightly-check-ci-reports + path: '**/build/reports/tests/**' + - name: Publish Test Results uses: scacap/action-surefire-report@v1 + if: ${{ github.repository_owner == 'deephaven' }} + env: + NODE_OPTIONS: '--max_old_space_size=4096' + with: + check_name: check report + github_token: ${{ secrets.GITHUB_TOKEN }} + report_paths: '**/build/test-results/*/TEST-*.xml' + + testSerial: + runs-on: ubuntu-20.04 + steps: + - name: Checkout + uses: actions/checkout@v2 + + # note: this uses Zulu and not AdoptOpenJDK or other. should make sure we build and test on the same one... + - name: Setup JDK + id: setup-java + uses: actions/setup-java@v1 + with: + java-version: '8.0.292' + + - name: Setup gradle properties + run: | + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties + + - name: Run gradle + uses: burrunan/gradle-cache-action@v1 + with: + job-id: testSerial + arguments: --scan --continue --rerun-tasks testSerial + gradle-version: wrapper + + - name: Upload Test Results + uses: actions/upload-artifact@v2 if: always() + with: + name: nightly-testSerial-ci-results + path: '**/build/test-results/*/TEST-*.xml' + + - name: Upload Test Reports + uses: actions/upload-artifact@v2 + if: always() + with: + name: nightly-testSerial-ci-reports + path: '**/build/reports/tests/**' + + - name: Publish Test Results + uses: scacap/action-surefire-report@v1 + if: ${{ github.repository_owner == 'deephaven' }} env: NODE_OPTIONS: '--max_old_space_size=4096' with: - check_name: nightly-check-ci test report + check_name: testSerial report github_token: ${{ secrets.GITHUB_TOKEN }} report_paths: '**/build/test-results/*/TEST-*.xml' + + testParallel: + runs-on: ubuntu-20.04 + steps: + - name: Checkout + uses: actions/checkout@v2 + + # note: this uses Zulu and not AdoptOpenJDK or other. should make sure we build and test on the same one... + - name: Setup JDK + id: setup-java + uses: actions/setup-java@v1 + with: + java-version: '8.0.292' + + - name: Setup gradle properties + run: | + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties + + - name: Run gradle + uses: burrunan/gradle-cache-action@v1 + with: + job-id: testParallel + arguments: --scan --continue --rerun-tasks testParallel + gradle-version: wrapper + + - name: Upload Test Results + uses: actions/upload-artifact@v2 + if: always() + with: + name: nightly-testParallel-ci-results + path: '**/build/test-results/*/TEST-*.xml' + + - name: Upload Test Reports + uses: actions/upload-artifact@v2 + if: always() + with: + name: nightly-testParallel-ci-reports + path: '**/build/reports/tests/**' + + - name: Publish Test Results + uses: scacap/action-surefire-report@v1 + if: ${{ github.repository_owner == 'deephaven' }} + env: + NODE_OPTIONS: '--max_old_space_size=4096' + with: + check_name: testParallel report + github_token: ${{ secrets.GITHUB_TOKEN }} + report_paths: '**/build/test-results/*/TEST-*.xml' + + testOutOfBand: + runs-on: ubuntu-20.04 + steps: + - name: Checkout + uses: actions/checkout@v2 + + # note: this uses Zulu and not AdoptOpenJDK or other. should make sure we build and test on the same one... + - name: Setup JDK + id: setup-java + uses: actions/setup-java@v1 + with: + java-version: '8.0.292' + + - name: Setup gradle properties + run: | + cat .github/env/${{ runner.os }}/gradle.properties >> gradle.properties + echo "org.gradle.java.installations.paths=${{ steps.setup-java.outputs.path }}" >> gradle.properties + + - name: Run gradle + uses: burrunan/gradle-cache-action@v1 + with: + job-id: testOutOfBand + arguments: --scan --continue --rerun-tasks testOutOfBand + gradle-version: wrapper + + - name: Upload Test Results + uses: actions/upload-artifact@v2 + if: always() + with: + name: nightly-testOutOfBand-ci-results + path: '**/build/test-results/*/TEST-*.xml' + + - name: Upload Test Reports + uses: actions/upload-artifact@v2 + if: always() + with: + name: nightly-testOutOfBand-ci-reports + path: '**/build/reports/tests/**' + + - name: Publish Test Results + uses: scacap/action-surefire-report@v1 + if: ${{ github.repository_owner == 'deephaven' }} + env: + NODE_OPTIONS: '--max_old_space_size=4096' + with: + check_name: testOutOfBand report + github_token: ${{ secrets.GITHUB_TOKEN }} + report_paths: '**/build/test-results/*/TEST-*.xml' \ No newline at end of file diff --git a/ClientSupport/src/main/java/io/deephaven/treetable/AbstractTreeSnapshotImpl.java b/ClientSupport/src/main/java/io/deephaven/treetable/AbstractTreeSnapshotImpl.java index f894b8626c8..02ff8ab3763 100644 --- a/ClientSupport/src/main/java/io/deephaven/treetable/AbstractTreeSnapshotImpl.java +++ b/ClientSupport/src/main/java/io/deephaven/treetable/AbstractTreeSnapshotImpl.java @@ -3,6 +3,7 @@ import io.deephaven.base.Pair; import io.deephaven.base.verify.Assert; import io.deephaven.configuration.Configuration; +import io.deephaven.internal.log.LoggerFactory; import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.live.NotificationQueue; @@ -49,13 +50,12 @@ public abstract class AbstractTreeSnapshotImpl tablesByKey, long firstRow, long lastRow, @@ -81,7 +80,6 @@ public abstract class AbstractTreeSnapshotImpl tablesByKey, long firstRow, @@ -53,7 +50,7 @@ class RollupSnapshotImpl sorts, CLIENT_TYPE client, Set includedOps) { - super(log, baseTableId, baseTable, tablesByKey, firstRow, lastRow, columns, filters, sorts, client, includedOps); + super(baseTableId, baseTable, tablesByKey, firstRow, lastRow, columns, filters, sorts, client, includedOps); if(getInfo().includesConstituents()) { final List updated = maybeComputeConstituentSorts(sorts); diff --git a/ClientSupport/src/main/java/io/deephaven/treetable/TreeSnapshotQuery.java b/ClientSupport/src/main/java/io/deephaven/treetable/TreeSnapshotQuery.java index a0ef9098e60..80427496a67 100644 --- a/ClientSupport/src/main/java/io/deephaven/treetable/TreeSnapshotQuery.java +++ b/ClientSupport/src/main/java/io/deephaven/treetable/TreeSnapshotQuery.java @@ -3,7 +3,6 @@ import io.deephaven.base.Function; import io.deephaven.base.formatters.FormatBitSet; import io.deephaven.base.verify.Assert; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.remote.AsyncMethod; import io.deephaven.db.v2.HierarchicalTable; @@ -12,7 +11,6 @@ import io.deephaven.db.v2.TreeTableInfo; import io.deephaven.db.v2.select.SelectFilter; import io.deephaven.table.sort.SortDirective; -import io.deephaven.internal.log.LoggerFactory; import org.jetbrains.annotations.NotNull; import java.util.*; @@ -22,8 +20,6 @@ */ public class TreeSnapshotQuery> implements Function.Unary { - private static final Logger log = LoggerFactory.getLogger(TreeSnapshotQuery.class); - private final CLIENT_TYPE client; private final long firstViewportRow; @@ -86,10 +82,10 @@ public TreeSnapshotResult call(Table arg) { final HierarchicalTableInfo sourceInfoAttr = ((HierarchicalTable)arg).getInfo(); if(sourceInfoAttr instanceof TreeTableInfo) { - return new TreeTableSnapshotImpl<>(log, baseTableId, (HierarchicalTable)arg, tablesByKey, + return new TreeTableSnapshotImpl<>(baseTableId, (HierarchicalTable)arg, tablesByKey, firstViewportRow, lastViewportRow, columns, filters, directives, client, includedOps).getSnapshot(); } else if(sourceInfoAttr instanceof RollupInfo) { - return new RollupSnapshotImpl<>(log, baseTableId, (HierarchicalTable)arg, tablesByKey, + return new RollupSnapshotImpl<>(baseTableId, (HierarchicalTable)arg, tablesByKey, firstViewportRow, lastViewportRow, columns, filters, directives, client, includedOps).getSnapshot(); } diff --git a/ClientSupport/src/main/java/io/deephaven/treetable/TreeTableSnapshotImpl.java b/ClientSupport/src/main/java/io/deephaven/treetable/TreeTableSnapshotImpl.java index 0b483a9da4a..91fb10f212a 100644 --- a/ClientSupport/src/main/java/io/deephaven/treetable/TreeTableSnapshotImpl.java +++ b/ClientSupport/src/main/java/io/deephaven/treetable/TreeTableSnapshotImpl.java @@ -1,7 +1,6 @@ package io.deephaven.treetable; import io.deephaven.configuration.Configuration; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.live.NotificationQueue; import io.deephaven.db.v2.*; @@ -30,7 +29,6 @@ class TreeTableSnapshotImpl tablesByKey, long firstRow, @@ -53,7 +50,7 @@ class TreeTableSnapshotImpl sorts, CLIENT_TYPE client, Set includedOps) { - super(log, baseTableId, baseTable, tablesByKey, firstRow, lastRow, columns, filters, sorts, client, includedOps); + super(baseTableId, baseTable, tablesByKey, firstRow, lastRow, columns, filters, sorts, client, includedOps); } @Override @@ -70,7 +67,7 @@ Table prepareRootTable() { boolean reTreeRequired = false; if (filters.length > 0) { - prepared = TreeTableFilter.rawFilterTree(log, baseTable, filters); + prepared = TreeTableFilter.rawFilterTree(baseTable, filters); reTreeRequired = true; } else { prepared = baseTable.getSourceTable(); diff --git a/ClientSupport/src/test/java/io/deephaven/treetable/TreeSnapshotQueryTest.java b/ClientSupport/src/test/java/io/deephaven/treetable/TreeSnapshotQueryTest.java index bec7b0ddd8c..ced900b159a 100644 --- a/ClientSupport/src/test/java/io/deephaven/treetable/TreeSnapshotQueryTest.java +++ b/ClientSupport/src/test/java/io/deephaven/treetable/TreeSnapshotQueryTest.java @@ -2,7 +2,6 @@ import io.deephaven.base.Pair; import io.deephaven.datastructures.util.SmartKey; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.libs.QueryLibrary; import io.deephaven.db.tables.live.LiveTableMonitor; @@ -465,7 +464,7 @@ public void testSortandFilter() throws IOException { testViewportAgainst(sortThenTree, state, 7, 51, allColumns, directives, SelectFilter.ZERO_LENGTH_SELECT_FILTER_ARRAY, true); - final Table filterThenTree = TreeTableFilter.filterTree(Logger.NULL, makeNyMunisTreeTable(), + final Table filterThenTree = TreeTableFilter.filterTree(makeNyMunisTreeTable(), "!isNull(Website) && Website.contains(`ny`)"); state.setCompareToTable(filterThenTree); @@ -473,7 +472,7 @@ public void testSortandFilter() throws IOException { // Deliberately sorting first than filtering, it will produce the same result and is a different order than TSQ does, // so validates things nicely. - final Table filterAndSortThenTree = TreeTableFilter.filterTree(Logger.NULL, getRawNyMunis() + final Table filterAndSortThenTree = TreeTableFilter.filterTree(getRawNyMunis() .sortDescending("County_Name", "Town_Name") .treeTable("Path", "Direct"), "!isNull(Website) && Website.contains(`ny`)"); diff --git a/DB-test/src/test/java/io/deephaven/db/util/TestWorkerPythonEnvironment.java b/DB-test/src/test/java/io/deephaven/db/util/TestWorkerPythonEnvironment.java index 7755e13ef80..676a35fac3f 100644 --- a/DB-test/src/test/java/io/deephaven/db/util/TestWorkerPythonEnvironment.java +++ b/DB-test/src/test/java/io/deephaven/db/util/TestWorkerPythonEnvironment.java @@ -43,7 +43,7 @@ public void testNumpyImport() { } public void testTimeTable() throws IOException { - WorkerPythonEnvironment.DEFAULT.eval("tt = db.timeTable(\"00:00:01\")"); + WorkerPythonEnvironment.DEFAULT.eval("tt = timeTable(\"00:00:01\")"); Object result = WorkerPythonEnvironment.DEFAULT.getValue("tt"); assertTrue(result instanceof Table); Table tt = (Table) result; diff --git a/DB/DB.gradle b/DB/DB.gradle index ebf886d5c08..52ad0f56327 100644 --- a/DB/DB.gradle +++ b/DB/DB.gradle @@ -262,18 +262,20 @@ test { // Adds a custom testParallel task which is allowed to run tests in parallel. // Add @Category(ParallelTest.class) to have your tests run in parallel // Note: Supports JUnit4 or greater only (you use @Test annotations to mark test methods). -// testParallel: parallel, not a db test, not isolated -TestTools.addDbTest(project, 'Parallel', true) + +// The Parallel tests are now functionally equivalent to the Serial test logic +// TODO (deephaven-core#643): Fix "leaking" parallel tests +TestTools.addDbTest(project, 'Parallel', false, false, true) // testSerial: non-parallel, not a db test, isolated TestTools.addDbTest(project, 'Serial', false, false, true) // testOutOfBand: non-parallel, not a db test, not isolated TestTools.addDbTest(project, 'OutOfBand', false, false, false) +// The configuration of this with respect to the build environment isn't very tight. +// Ideally, the build environment would be able to configure this as appropriate. tasks.testParallel.maxHeapSize = '6g' tasks.testSerial.maxHeapSize = '6g' tasks.testOutOfBand.maxHeapSize = '6g' tasks.test.maxHeapSize = '6g' -// consider giving all our tests a mountain of RAM: -// tasks.withType(Test)*.maxHeapSize = '12g' Tools.applyAnnotationProcessorPathHacks(project, true) diff --git a/DB/src/main/java/io/deephaven/db/tables/utils/TableToolsMergeHelper.java b/DB/src/main/java/io/deephaven/db/tables/utils/TableToolsMergeHelper.java index 9e8cb9ffd18..dc1e5987114 100644 --- a/DB/src/main/java/io/deephaven/db/tables/utils/TableToolsMergeHelper.java +++ b/DB/src/main/java/io/deephaven/db/tables/utils/TableToolsMergeHelper.java @@ -1,8 +1,6 @@ package io.deephaven.db.tables.utils; import io.deephaven.base.verify.Assert; -import io.deephaven.io.logger.Logger; -import io.deephaven.util.process.ProcessEnvironment; import io.deephaven.db.tables.ColumnDefinition; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.TableDefinition; @@ -23,7 +21,6 @@ * */ public class TableToolsMergeHelper { - private static final Logger staticLog_ = ProcessEnvironment.getDefaultLog(TableToolsMergeHelper.class); public static Table mergeTableMap(LocalTableMap tableMap) { final List tablesToMergeOrNull = getTablesToMerge(tableMap.values().stream(), tableMap.size()); @@ -71,7 +68,7 @@ public static Table mergeInternal(TableDefinition tableDef, List
tables, LiveTableMonitor.DEFAULT.checkInitiateTableOperation(); } - final UnionSourceManager unionSourceManager = new UnionSourceManager(staticLog_, tableDef, parentDependency); + final UnionSourceManager unionSourceManager = new UnionSourceManager(tableDef, parentDependency); final QueryTable queryTable = unionSourceManager.getResult(); for (Table table : tables) { diff --git a/DB/src/main/java/io/deephaven/db/tables/utils/WindowCheck.java b/DB/src/main/java/io/deephaven/db/tables/utils/WindowCheck.java index f7730bb9283..5faf220d8ab 100644 --- a/DB/src/main/java/io/deephaven/db/tables/utils/WindowCheck.java +++ b/DB/src/main/java/io/deephaven/db/tables/utils/WindowCheck.java @@ -4,8 +4,6 @@ import io.deephaven.base.verify.Assert; import io.deephaven.base.verify.Require; import io.deephaven.datastructures.util.CollectionUtil; -import io.deephaven.io.logger.Logger; -import io.deephaven.util.process.ProcessEnvironment; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.live.LiveTable; import io.deephaven.db.tables.live.LiveTableMonitor; @@ -48,7 +46,7 @@ private WindowCheck() {} */ @SuppressWarnings("unused") public static Table addTimeWindow(Table table, String timestampColumn, long windowNanos, String inWindowColumn) { - return addTimeWindowInternal(ProcessEnvironment.getDefaultLog(), null, table, timestampColumn, windowNanos, inWindowColumn, true).first; + return addTimeWindowInternal(null, table, timestampColumn, windowNanos, inWindowColumn, true).first; } private static class WindowListenerRecorder extends ListenerRecorder { @@ -64,7 +62,7 @@ private WindowListenerRecorder(DynamicTable parent, DynamicTable dependent) { * @param addToMonitor should we add this to the LiveTableMonitor * @return a pair of the result table and the TimeWindowListener that drives it */ - static Pair addTimeWindowInternal(Logger log, TimeProvider timeProvider, Table table, String timestampColumn, long windowNanos, String inWindowColumn, boolean addToMonitor) { + static Pair addTimeWindowInternal(TimeProvider timeProvider, Table table, String timestampColumn, long windowNanos, String inWindowColumn, boolean addToMonitor) { final Map resultColumns = new LinkedHashMap<>(table.getColumnSourceMap()); final InWindowColumnSource inWindowColumnSource; @@ -81,7 +79,7 @@ static Pair addTimeWindowInternal(Logger log, TimePro if (table instanceof DynamicTable) { final DynamicTable dynamicSource = (DynamicTable) table; final WindowListenerRecorder recorder = new WindowListenerRecorder(dynamicSource, result); - final TimeWindowListener timeWindowListener = new TimeWindowListener(log, inWindowColumn, inWindowColumnSource, recorder, dynamicSource, result); + final TimeWindowListener timeWindowListener = new TimeWindowListener(inWindowColumn, inWindowColumnSource, recorder, dynamicSource, result); recorder.setMergedListener(timeWindowListener); dynamicSource.listenForUpdates(recorder); table.getIndex().forAllLongs(timeWindowListener::addIndex); @@ -148,9 +146,9 @@ public String toString() { * @param source the source table * @param result our initialized result table */ - private TimeWindowListener(final Logger log, final String inWindowColumnName, final InWindowColumnSource inWindowColumnSource, + private TimeWindowListener(final String inWindowColumnName, final InWindowColumnSource inWindowColumnSource, final ListenerRecorder recorder, final DynamicTable source, final QueryTable result) { - super(log, Collections.singleton(recorder), Collections.singleton(source), "WindowCheck", result); + super(Collections.singleton(recorder), Collections.singleton(source), "WindowCheck", result); this.source = source; this.recorder = recorder; this.inWindowColumnSource = inWindowColumnSource; diff --git a/DB/src/main/java/io/deephaven/db/v2/AsOfJoinHelper.java b/DB/src/main/java/io/deephaven/db/v2/AsOfJoinHelper.java index 55d8bdd01e6..0fa7634ea0b 100644 --- a/DB/src/main/java/io/deephaven/db/v2/AsOfJoinHelper.java +++ b/DB/src/main/java/io/deephaven/db/v2/AsOfJoinHelper.java @@ -2,7 +2,6 @@ import io.deephaven.base.Pair; import io.deephaven.base.verify.Assert; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.SortingOrder; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.select.MatchPair; @@ -37,12 +36,12 @@ public class AsOfJoinHelper { private AsOfJoinHelper() {} // static use only - static Table asOfJoin(@SuppressWarnings("SameParameterValue") Logger log, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, SortingOrder order, boolean disallowExactMatch) { + static Table asOfJoin(QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, SortingOrder order, boolean disallowExactMatch) { final JoinControl joinControl = new JoinControl(); - return asOfJoin(log, joinControl, leftTable, rightTable, columnsToMatch, columnsToAdd, order, disallowExactMatch); + return asOfJoin(joinControl, leftTable, rightTable, columnsToMatch, columnsToAdd, order, disallowExactMatch); } - static Table asOfJoin(Logger log, JoinControl control, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, SortingOrder order, boolean disallowExactMatch) { + static Table asOfJoin(JoinControl control, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, SortingOrder order, boolean disallowExactMatch) { if (columnsToMatch.length == 0) { throw new IllegalArgumentException("aj() requires at least one column to match!"); } @@ -78,12 +77,12 @@ static Table asOfJoin(Logger log, JoinControl control, QueryTable leftTable, Que final RedirectionIndex redirectionIndex = makeRedirectionIndex(control, leftTable); if (keyColumnCount == 0) { - return zeroKeyAj(log, control, leftTable, rightTable, columnsToAdd, stampPair, leftStampSource, originalRightStampSource, rightStampSource, order, disallowExactMatch, redirectionIndex); + return zeroKeyAj(control, leftTable, rightTable, columnsToAdd, stampPair, leftStampSource, originalRightStampSource, rightStampSource, order, disallowExactMatch, redirectionIndex); } if (rightTable.isLive()) { if (leftTable.isLive()) { - return bothIncrementalAj(log,control, leftTable, rightTable, columnsToMatch, columnsToAdd, order, disallowExactMatch, stampPair, + return bothIncrementalAj(control, leftTable, rightTable, columnsToMatch, columnsToAdd, order, disallowExactMatch, stampPair, leftSources, rightSources, leftStampSource, rightStampSource, redirectionIndex); } return rightTickingLeftStaticAj(control, leftTable, rightTable, columnsToMatch, columnsToAdd, order, disallowExactMatch, stampPair, leftSources, rightSources, leftStampSource, rightStampSource, redirectionIndex); @@ -474,9 +473,9 @@ private static RedirectionIndex makeRedirectionIndex(JoinControl control, QueryT return redirectionIndex; } - private static Table zeroKeyAj(Logger log, JoinControl control, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToAdd, MatchPair stampPair, ColumnSource leftStampSource, ColumnSource originalRightStampSource, ColumnSource rightStampSource, SortingOrder order, boolean disallowExactMatch, final RedirectionIndex redirectionIndex) { + private static Table zeroKeyAj(JoinControl control, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToAdd, MatchPair stampPair, ColumnSource leftStampSource, ColumnSource originalRightStampSource, ColumnSource rightStampSource, SortingOrder order, boolean disallowExactMatch, final RedirectionIndex redirectionIndex) { if (rightTable.isLive() && leftTable.isLive()) { - return zeroKeyAjBothIncremental(log, control, leftTable, rightTable, columnsToAdd, stampPair, leftStampSource, rightStampSource, order, disallowExactMatch, redirectionIndex); + return zeroKeyAjBothIncremental(control, leftTable, rightTable, columnsToAdd, stampPair, leftStampSource, rightStampSource, order, disallowExactMatch, redirectionIndex); } else if (rightTable.isLive()) { return zeroKeyAjRightIncremental(control, leftTable, rightTable, columnsToAdd, stampPair, leftStampSource, rightStampSource, order, disallowExactMatch, redirectionIndex); } else { @@ -798,8 +797,7 @@ public void onUpdate(Update upstream) { public interface SsaFactory extends Function, SafeCloseable { } - private static Table bothIncrementalAj(Logger log, - JoinControl control, + private static Table bothIncrementalAj(JoinControl control, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, @@ -906,7 +904,7 @@ public SegmentedSortedArray apply(Index leftIndex) { final JoinListenerRecorder leftRecorder = new JoinListenerRecorder(true, listenerDescription, leftTable, result); final JoinListenerRecorder rightRecorder = new JoinListenerRecorder(false, listenerDescription, rightTable, result); - final BucketedChunkedAjMergedListener mergedJoinListener = new BucketedChunkedAjMergedListener(log, leftRecorder, rightRecorder, + final BucketedChunkedAjMergedListener mergedJoinListener = new BucketedChunkedAjMergedListener(leftRecorder, rightRecorder, listenerDescription, result, leftTable, rightTable, columnsToMatch, stampPair, columnsToAdd, leftSources, rightSources, leftStampSource, rightStampSource, leftSsaFactory, rightSsaFactory, order, disallowExactMatch, @@ -926,7 +924,7 @@ public SegmentedSortedArray apply(Index leftIndex) { return result; } - private static Table zeroKeyAjBothIncremental(Logger log, JoinControl control, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToAdd, MatchPair stampPair, ColumnSource leftStampSource, ColumnSource rightStampSource, SortingOrder order, boolean disallowExactMatch, final RedirectionIndex redirectionIndex) { + private static Table zeroKeyAjBothIncremental(JoinControl control, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToAdd, MatchPair stampPair, ColumnSource leftStampSource, ColumnSource rightStampSource, SortingOrder order, boolean disallowExactMatch, final RedirectionIndex redirectionIndex) { final boolean reverse = order == SortingOrder.Descending; final ChunkType stampChunkType = rightStampSource.getChunkType(); @@ -947,7 +945,7 @@ private static Table zeroKeyAjBothIncremental(Logger log, JoinControl control, Q final JoinListenerRecorder leftRecorder = new JoinListenerRecorder(true, listenerDescription, leftTable, result); final JoinListenerRecorder rightRecorder = new JoinListenerRecorder(false, listenerDescription, rightTable, result); - final ZeroKeyChunkedAjMergedListener mergedJoinListener = new ZeroKeyChunkedAjMergedListener(log, leftRecorder, rightRecorder, + final ZeroKeyChunkedAjMergedListener mergedJoinListener = new ZeroKeyChunkedAjMergedListener(leftRecorder, rightRecorder, listenerDescription, result, leftTable, rightTable, stampPair, columnsToAdd, leftStampSource, rightStampSource, order, disallowExactMatch, ssaSsaStamp, leftSsa, rightSsa, redirectionIndex, control); diff --git a/DB/src/main/java/io/deephaven/db/v2/BaseTable.java b/DB/src/main/java/io/deephaven/db/v2/BaseTable.java index 785fc736478..edbe4b6b613 100644 --- a/DB/src/main/java/io/deephaven/db/v2/BaseTable.java +++ b/DB/src/main/java/io/deephaven/db/v2/BaseTable.java @@ -1333,7 +1333,7 @@ public void initializeWithSnapshot( } public interface SwapListenerFactory { - T newListener(Logger log, BaseTable sourceTable); + T newListener(BaseTable sourceTable); } /** @@ -1349,7 +1349,7 @@ public T createSwapListenerIfRefreshing(final SwapL return null; } - final T swapListener = factory.newListener(log, this); + final T swapListener = factory.newListener(this); swapListener.subscribeForUpdates(); return swapListener; } diff --git a/DB/src/main/java/io/deephaven/db/v2/CrossJoinHelper.java b/DB/src/main/java/io/deephaven/db/v2/CrossJoinHelper.java index c787f0611f7..c5bc629b6a0 100644 --- a/DB/src/main/java/io/deephaven/db/v2/CrossJoinHelper.java +++ b/DB/src/main/java/io/deephaven/db/v2/CrossJoinHelper.java @@ -3,7 +3,6 @@ import io.deephaven.base.verify.Assert; import io.deephaven.configuration.Configuration; import io.deephaven.datastructures.util.CollectionUtil; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.select.MatchPair; import io.deephaven.db.v2.join.JoinListenerRecorder; @@ -44,17 +43,17 @@ public class CrossJoinHelper { private CrossJoinHelper() { } - static Table join(final Logger log, final QueryTable leftTable, final QueryTable rightTable, final MatchPair[] columnsToMatch, final MatchPair[] columnsToAdd, final int numReserveRightBits) { - return join(log, leftTable, rightTable, columnsToMatch, columnsToAdd, numReserveRightBits, new JoinControl()); + static Table join(final QueryTable leftTable, final QueryTable rightTable, final MatchPair[] columnsToMatch, final MatchPair[] columnsToAdd, final int numReserveRightBits) { + return join(leftTable, rightTable, columnsToMatch, columnsToAdd, numReserveRightBits, new JoinControl()); } - static Table join(final Logger log, final QueryTable leftTable, final QueryTable rightTable, final MatchPair[] columnsToMatch, final MatchPair[] columnsToAdd, final int numReserveRightBits, final JoinControl control) { - final Table result = internalJoin(log, leftTable, rightTable, columnsToMatch, columnsToAdd, numReserveRightBits, control); + static Table join(final QueryTable leftTable, final QueryTable rightTable, final MatchPair[] columnsToMatch, final MatchPair[] columnsToAdd, final int numReserveRightBits, final JoinControl control) { + final Table result = internalJoin(leftTable, rightTable, columnsToMatch, columnsToAdd, numReserveRightBits, control); leftTable.maybeCopyColumnDescriptions(result, rightTable, columnsToMatch, columnsToAdd); return result; } - private static Table internalJoin(final Logger log, final QueryTable leftTable, final QueryTable rightTable, final MatchPair[] columnsToMatch, final MatchPair[] columnsToAdd, int numRightBitsToReserve, final JoinControl control) { + private static Table internalJoin(final QueryTable leftTable, final QueryTable rightTable, final MatchPair[] columnsToMatch, final MatchPair[] columnsToAdd, int numRightBitsToReserve, final JoinControl control) { QueryTable.checkInitiateOperation(leftTable); QueryTable.checkInitiateOperation(rightTable); @@ -65,7 +64,7 @@ private static Table internalJoin(final Logger log, final QueryTable leftTable, if (!leftTable.isLive() && !rightTable.isLive()) { numRightBitsToReserve = 1; // tight computation of this is efficient and appropriate } - return zeroKeyColumnsJoin(log, leftTable, rightTable, columnsToAdd, numRightBitsToReserve, bucketingContext.listenerDescription); + return zeroKeyColumnsJoin(leftTable, rightTable, columnsToAdd, numRightBitsToReserve, bucketingContext.listenerDescription); } final ModifiedColumnSet rightKeyColumns = rightTable.newModifiedColumnSet(MatchPair.getRightColumns(columnsToMatch)); @@ -210,7 +209,7 @@ public void onUpdate(final Update upstream) { // - Handle left adds. // - Generate downstream MCS. // - Propagate and Profit. - final MergedListener mergedListener = new MergedListener(log, Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), bucketingContext.listenerDescription, resultTable) { + final MergedListener mergedListener = new MergedListener(Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), bucketingContext.listenerDescription, resultTable) { private final CrossJoinModifiedSlotTracker tracker = new CrossJoinModifiedSlotTracker(jsm); @Override @@ -793,7 +792,7 @@ private static void validateZeroKeyIndexSpace(final QueryTable leftTable, final } @NotNull - private static Table zeroKeyColumnsJoin(Logger log, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToAdd, int numRightBitsToReserve, String listenerDescription) { + private static Table zeroKeyColumnsJoin(QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToAdd, int numRightBitsToReserve, String listenerDescription) { // we are a single value join, we do not need to do any hash-related work validateZeroKeyIndexSpace(leftTable, rightTable, numRightBitsToReserve); final CrossJoinShiftState crossJoinState = new CrossJoinShiftState(Math.max(numRightBitsToReserve, CrossJoinShiftState.getMinBits(rightTable))); @@ -1009,7 +1008,7 @@ private static Table zeroKeyColumnsJoin(Logger log, QueryTable leftTable, QueryT final JoinListenerRecorder leftRecorder = new JoinListenerRecorder(true, listenerDescription, leftTable, result); final JoinListenerRecorder rightRecorder = new JoinListenerRecorder(false, listenerDescription, rightTable, result); - final MergedListener mergedListener = new MergedListener(log, Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result) { + final MergedListener mergedListener = new MergedListener(Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result) { @Override protected void process() { onUpdate.accept(leftRecorder.getUpdate(), rightRecorder.getUpdate()); diff --git a/DB/src/main/java/io/deephaven/db/v2/MergedListener.java b/DB/src/main/java/io/deephaven/db/v2/MergedListener.java index 8b8290932f7..3de8b654fbb 100644 --- a/DB/src/main/java/io/deephaven/db/v2/MergedListener.java +++ b/DB/src/main/java/io/deephaven/db/v2/MergedListener.java @@ -6,6 +6,7 @@ import io.deephaven.base.log.LogOutput; import io.deephaven.base.verify.Assert; +import io.deephaven.internal.log.LoggerFactory; import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.live.LiveTableMonitor; import io.deephaven.db.tables.live.NotificationQueue; @@ -31,7 +32,8 @@ * produce notifications more than once in a cycle; which is an error. */ public abstract class MergedListener extends LivenessArtifact implements NotificationQueue.Dependency { - private final Logger log; + private static final Logger log = LoggerFactory.getLogger(MergedListener.class); + @SuppressWarnings({"FieldCanBeLocal", "unused"}) private final String logPrefix; @@ -47,8 +49,7 @@ public abstract class MergedListener extends LivenessArtifact implements Notific private final UpdatePerformanceTracker.Entry entry; - protected MergedListener(Logger log, Collection recorders, Collection dependencies, String listenerDescription, QueryTable result) { - this.log = log; + protected MergedListener(Collection recorders, Collection dependencies, String listenerDescription, QueryTable result) { this.recorders = recorders; recorders.forEach(this::manage); this.dependencies = dependencies; diff --git a/DB/src/main/java/io/deephaven/db/v2/NaturalJoinHelper.java b/DB/src/main/java/io/deephaven/db/v2/NaturalJoinHelper.java index 50f66d76e21..107052654b9 100644 --- a/DB/src/main/java/io/deephaven/db/v2/NaturalJoinHelper.java +++ b/DB/src/main/java/io/deephaven/db/v2/NaturalJoinHelper.java @@ -3,7 +3,6 @@ import io.deephaven.base.Pair; import io.deephaven.base.verify.Assert; import io.deephaven.datastructures.util.CollectionUtil; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.select.MatchPair; import io.deephaven.db.v2.join.JoinListenerRecorder; @@ -21,18 +20,18 @@ class NaturalJoinHelper { private NaturalJoinHelper() {} // static use only - static Table naturalJoin(@SuppressWarnings("SameParameterValue") Logger log, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, boolean exactMatch) { - return naturalJoin(log, leftTable, rightTable, columnsToMatch, columnsToAdd, exactMatch, new JoinControl()); + static Table naturalJoin(QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, boolean exactMatch) { + return naturalJoin(leftTable, rightTable, columnsToMatch, columnsToAdd, exactMatch, new JoinControl()); } @VisibleForTesting - static Table naturalJoin(Logger log, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, boolean exactMatch, JoinControl control) { - final Table result = naturalJoinInternal(log, leftTable, rightTable, columnsToMatch, columnsToAdd, exactMatch, control); + static Table naturalJoin(QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, boolean exactMatch, JoinControl control) { + final Table result = naturalJoinInternal(leftTable, rightTable, columnsToMatch, columnsToAdd, exactMatch, control); leftTable.maybeCopyColumnDescriptions(result, rightTable, columnsToMatch, columnsToAdd); return result; } - private static Table naturalJoinInternal(Logger log, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, boolean exactMatch, JoinControl control) { + private static Table naturalJoinInternal(QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, boolean exactMatch, JoinControl control) { try (final BucketingContext bucketingContext = new BucketingContext("naturalJoin", leftTable, rightTable, columnsToMatch, columnsToAdd, control)) { // if we have a single column of unique values, and the range is small, we can use a simplified table @@ -56,7 +55,7 @@ private static Table naturalJoinInternal(Logger log, QueryTable leftTable, Query } if (bucketingContext.leftSources.length == 0) { - return zeroKeyColumnsJoin(log, leftTable, rightTable, columnsToAdd, exactMatch, bucketingContext.listenerDescription); + return zeroKeyColumnsJoin(leftTable, rightTable, columnsToAdd, exactMatch, bucketingContext.listenerDescription); } final LongArraySource leftHashSlots = new LongArraySource(); @@ -88,7 +87,7 @@ private static Table naturalJoinInternal(Logger log, QueryTable leftTable, Query jsm.setTargetLoadFactor(control.getTargetLoadFactor()); final ChunkedMergedJoinListener mergedJoinListener = new ChunkedMergedJoinListener( - log, leftTable, rightTable, bucketingContext.leftSources, bucketingContext.rightSources, columnsToMatch, + leftTable, rightTable, bucketingContext.leftSources, bucketingContext.rightSources, columnsToMatch, columnsToAdd, leftRecorder, rightRecorder, result, redirectionIndex, jsm, exactMatch, bucketingContext.listenerDescription); leftRecorder.setMergedListener(mergedJoinListener); rightRecorder.setMergedListener(mergedJoinListener); @@ -182,7 +181,7 @@ private static Table naturalJoinInternal(Logger log, QueryTable leftTable, Query } @NotNull - private static Table zeroKeyColumnsJoin(Logger log, QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToAdd, boolean exactMatch, String listenerDescription) { + private static Table zeroKeyColumnsJoin(QueryTable leftTable, QueryTable rightTable, MatchPair[] columnsToAdd, boolean exactMatch, String listenerDescription) { // we are a single value join, we do not need to do any work final SingleValueRedirectionIndex redirectionIndex; @@ -213,7 +212,7 @@ private static Table zeroKeyColumnsJoin(Logger log, QueryTable leftTable, QueryT final JoinListenerRecorder leftRecorder = new JoinListenerRecorder(true, listenerDescription, leftTable, result); final JoinListenerRecorder rightRecorder = new JoinListenerRecorder(false, listenerDescription, rightTable, result); - final MergedListener mergedListener = new MergedListener(log, Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result) { + final MergedListener mergedListener = new MergedListener(Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result) { @Override protected void process() { result.modifiedColumnSet.clear(); @@ -654,7 +653,7 @@ private static class ChunkedMergedJoinListener extends MergedListener { private final NaturalJoinModifiedSlotTracker modifiedSlotTracker; - private ChunkedMergedJoinListener(Logger log, QueryTable leftTable, + private ChunkedMergedJoinListener(QueryTable leftTable, QueryTable rightTable, ColumnSource[] leftSources, ColumnSource[] rightSources, @@ -667,7 +666,7 @@ private ChunkedMergedJoinListener(Logger log, QueryTable leftTable, IncrementalChunkedNaturalJoinStateManager jsm, boolean exactMatch, String listenerDescription) { - super(log, Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result); + super(Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result); this.leftSources = leftSources; this.rightSources = rightSources; this.leftRecorder = leftRecorder; diff --git a/DB/src/main/java/io/deephaven/db/v2/QueryTable.java b/DB/src/main/java/io/deephaven/db/v2/QueryTable.java index 59fa4e00f65..81cb37aba5a 100644 --- a/DB/src/main/java/io/deephaven/db/v2/QueryTable.java +++ b/DB/src/main/java/io/deephaven/db/v2/QueryTable.java @@ -40,7 +40,6 @@ import io.deephaven.util.annotations.TestUseOnly; import io.deephaven.util.annotations.VisibleForTesting; import io.deephaven.internal.log.LoggerFactory; -import java.util.Map.Entry; import org.apache.commons.lang3.mutable.Mutable; import org.apache.commons.lang3.mutable.MutableLong; import org.apache.commons.lang3.mutable.MutableObject; @@ -57,7 +56,6 @@ import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; -import scala.reflect.internal.util.TableDef; import static io.deephaven.db.tables.select.MatchPair.matchString; @@ -102,8 +100,8 @@ public Result(final @NotNull T resultNode, */ String getLogPrefix(); - default ShiftAwareSwapListener newSwapListener(final Logger log, final QueryTable queryTable) { - return new ShiftAwareSwapListener(log, queryTable); + default ShiftAwareSwapListener newSwapListener(final QueryTable queryTable) { + return new ShiftAwareSwapListener(queryTable); } /** @@ -968,14 +966,14 @@ public Table where(final SelectFilter... filters) { .collect(Collectors.toList()); if (swapListener != null) { final ListenerRecorder recorder = new ListenerRecorder("where(" + Arrays.toString(filters) + ")", QueryTable.this, filteredTable); - final WhereListener whereListener = new WhereListener(log, recorder, dependencies, filteredTable); + final WhereListener whereListener = new WhereListener(recorder, dependencies, filteredTable); filteredTable.setWhereListener(whereListener); recorder.setMergedListener(whereListener); swapListener.setListenerAndResult(recorder, filteredTable); filteredTable.addParentReference(swapListener); filteredTable.addParentReference(whereListener); } else if (refreshingFilters) { - final StaticWhereListener whereListener = new StaticWhereListener(log, dependencies, filteredTable); + final StaticWhereListener whereListener = new StaticWhereListener(dependencies, filteredTable); filteredTable.setWhereListener(whereListener); filteredTable.addParentReference(whereListener); } @@ -1581,7 +1579,7 @@ private Table ajInternal(Table rightTable, MatchPair[] columnsToMatch, MatchPair throw new UnsupportedOperationException(); } - return AsOfJoinHelper.asOfJoin(log, this, (QueryTable)rightTable, columnsToMatch, columnsToAdd, order, disallowExactMatch); + return AsOfJoinHelper.asOfJoin(this, (QueryTable)rightTable, columnsToMatch, columnsToAdd, order, disallowExactMatch); } @Override @@ -1594,7 +1592,7 @@ private Table naturalJoinInternal(final Table rightTable, final MatchPair[] colu final QueryTable rightTableCoalesced = (QueryTable)rightTable.coalesce(); - return NaturalJoinHelper.naturalJoin(log, this, rightTableCoalesced, columnsToMatch, columnsToAdd, exactMatch); + return NaturalJoinHelper.naturalJoin(this, rightTableCoalesced, columnsToMatch, columnsToAdd, exactMatch); } private MatchPair[] createColumnsToAddIfMissing(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd) { @@ -1645,7 +1643,7 @@ private Table joinNoMemo(final Table rightTableCandidate, MatchPair[] columnsToM if (USE_CHUNKED_CROSS_JOIN) { final QueryTable coalescedRightTable = (QueryTable)rightTableCandidate.coalesce(); return QueryPerformanceRecorder.withNugget("join(" + matchString(columnsToMatch) + ", " + matchString(realColumnsToAdd) + ", " + numRightBitsToReserve + ")", () -> - CrossJoinHelper.join(log, this, coalescedRightTable, columnsToMatch, realColumnsToAdd, numRightBitsToReserve)); + CrossJoinHelper.join(this, coalescedRightTable, columnsToMatch, realColumnsToAdd, numRightBitsToReserve)); } final Set columnsToMatchSet = Arrays.stream(columnsToMatch).map(MatchPair::right).collect(Collectors.toCollection(HashSet::new)); @@ -1945,7 +1943,7 @@ public Table snapshotIncremental(final Table tableToSnapshot, final boolean doIn final ListenerRecorder leftListenerRecorder = new ListenerRecorder("snapshotIncremental (leftTable)", this, resultTable); listenForUpdates(leftListenerRecorder); - final SnapshotIncrementalListener listener = new SnapshotIncrementalListener(log, this, resultTable, resultColumns, + final SnapshotIncrementalListener listener = new SnapshotIncrementalListener(this, resultTable, resultColumns, rightListenerRecorder, leftListenerRecorder, rightTable, leftColumns); @@ -2818,7 +2816,7 @@ private T getResultNoMemo(fin final ShiftAwareSwapListener swapListener; if (isRefreshing()) { - swapListener = operation.newSwapListener(log, this); + swapListener = operation.newSwapListener(this); swapListener.subscribeForUpdates(); } else { swapListener = null; @@ -2850,8 +2848,8 @@ private class WhereListener extends MergedListener { private final ModifiedColumnSet filterColumns; private final ListenerRecorder recorder; - private WhereListener(Logger log, ListenerRecorder recorder, Collection dependencies, FilteredTable result) { - super(log, Collections.singleton(recorder), dependencies,"where(" + Arrays.toString(result.filters) + ")", result); + private WhereListener(ListenerRecorder recorder, Collection dependencies, FilteredTable result) { + super(Collections.singleton(recorder), dependencies,"where(" + Arrays.toString(result.filters) + ")", result); this.recorder = recorder; this.result = result; this.currentMapping = result.getIndex(); @@ -2933,8 +2931,8 @@ public void process() { private static class StaticWhereListener extends MergedListener { private final FilteredTable result; - private StaticWhereListener(Logger log, Collection dependencies, FilteredTable result) { - super(log, Collections.emptyList(), dependencies,"where(" + Arrays.toString(result.filters) + ")", result); + private StaticWhereListener(Collection dependencies, FilteredTable result) { + super(Collections.emptyList(), dependencies,"where(" + Arrays.toString(result.filters) + ")", result); this.result = result; } @@ -2968,6 +2966,6 @@ public R apply(Function.Unary function) { } public Table wouldMatch(WouldMatchPair... matchers) { - return getResult(new WouldMatchOperation(log, this, matchers)); + return getResult(new WouldMatchOperation(this, matchers)); } } diff --git a/DB/src/main/java/io/deephaven/db/v2/ReverseLookupListener.java b/DB/src/main/java/io/deephaven/db/v2/ReverseLookupListener.java index d8722eb2694..76d0ae9412c 100644 --- a/DB/src/main/java/io/deephaven/db/v2/ReverseLookupListener.java +++ b/DB/src/main/java/io/deephaven/db/v2/ReverseLookupListener.java @@ -37,7 +37,6 @@ * @IncludeAll */ public class ReverseLookupListener extends LivenessArtifact implements ReverseLookup, DynamicNode, NotificationStepSource { - private static final Logger log = ProcessEnvironment.getDefaultLog(ReverseLookupListener.class); private static final long NO_ENTRY_VALUE = -2; private static final long REMOVED_ENTRY_VALUE = -3; @@ -168,7 +167,7 @@ public String toString() { public static ReverseLookupListener makeReverseLookupListenerWithSnapshot(BaseTable source, String... columns) { final SwapListener swapListener; if (source.isRefreshing()) { - swapListener = new SwapListener(log, source); + swapListener = new SwapListener(source); source.listenForUpdates(swapListener); } else { swapListener = null; diff --git a/DB/src/main/java/io/deephaven/db/v2/ReverseOperation.java b/DB/src/main/java/io/deephaven/db/v2/ReverseOperation.java index 92bc0eeeb7f..ba30656481b 100644 --- a/DB/src/main/java/io/deephaven/db/v2/ReverseOperation.java +++ b/DB/src/main/java/io/deephaven/db/v2/ReverseOperation.java @@ -5,7 +5,6 @@ package io.deephaven.db.v2; import io.deephaven.base.verify.Assert; -import io.deephaven.io.logger.Logger; import io.deephaven.db.v2.sources.ColumnSource; import io.deephaven.db.v2.sources.LogicalClock; import io.deephaven.db.v2.sources.ReversedColumnSource; @@ -53,8 +52,8 @@ public MemoizedOperationKey getMemoizedOperationKey() { } @Override - public ShiftAwareSwapListener newSwapListener(Logger log, QueryTable queryTable) { - return new ShiftAwareSwapListener(log, queryTable) { + public ShiftAwareSwapListener newSwapListener(QueryTable queryTable) { + return new ShiftAwareSwapListener(queryTable) { @Override public synchronized boolean end(long clockCycle) { final boolean success = super.end(clockCycle); diff --git a/DB/src/main/java/io/deephaven/db/v2/ShiftAwareSwapListener.java b/DB/src/main/java/io/deephaven/db/v2/ShiftAwareSwapListener.java index 87c11e19c23..2705100a7e2 100644 --- a/DB/src/main/java/io/deephaven/db/v2/ShiftAwareSwapListener.java +++ b/DB/src/main/java/io/deephaven/db/v2/ShiftAwareSwapListener.java @@ -1,12 +1,11 @@ package io.deephaven.db.v2; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.live.NotificationQueue; public class ShiftAwareSwapListener extends SwapListenerBase implements ShiftAwareListener { - public ShiftAwareSwapListener(final Logger log, final BaseTable sourceTable) { - super(log, sourceTable); + public ShiftAwareSwapListener(final BaseTable sourceTable) { + super(sourceTable); } @Override diff --git a/DB/src/main/java/io/deephaven/db/v2/SortOperation.java b/DB/src/main/java/io/deephaven/db/v2/SortOperation.java index 3fb957a03fd..bd3ee4ab0c5 100644 --- a/DB/src/main/java/io/deephaven/db/v2/SortOperation.java +++ b/DB/src/main/java/io/deephaven/db/v2/SortOperation.java @@ -5,7 +5,6 @@ package io.deephaven.db.v2; import io.deephaven.base.verify.Require; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.SortPair; import io.deephaven.db.tables.SortingOrder; import io.deephaven.db.v2.hashing.HashMapK4V4; @@ -71,8 +70,8 @@ public MemoizedOperationKey getMemoizedOperationKey() { } @Override - public ShiftAwareSwapListener newSwapListener(Logger log, QueryTable queryTable) { - return new ShiftAwareSwapListener(log, queryTable) { + public ShiftAwareSwapListener newSwapListener(QueryTable queryTable) { + return new ShiftAwareSwapListener(queryTable) { @Override public synchronized boolean end(long clockCycle) { final boolean success = super.end(clockCycle); diff --git a/DB/src/main/java/io/deephaven/db/v2/SourceTable.java b/DB/src/main/java/io/deephaven/db/v2/SourceTable.java index 509e576f059..ad7d40bb44b 100644 --- a/DB/src/main/java/io/deephaven/db/v2/SourceTable.java +++ b/DB/src/main/java/io/deephaven/db/v2/SourceTable.java @@ -276,7 +276,7 @@ protected Collection filterLocations(@NotNull final Collection new ShiftAwareSwapListener(log, parent) { + final ShiftAwareSwapListener swapListener = createSwapListenerIfRefreshing((final BaseTable parent) -> new ShiftAwareSwapListener(parent) { @Override public final void destroy() { diff --git a/DB/src/main/java/io/deephaven/db/v2/SwapListener.java b/DB/src/main/java/io/deephaven/db/v2/SwapListener.java index b173ba128e9..2f2163b8c3b 100644 --- a/DB/src/main/java/io/deephaven/db/v2/SwapListener.java +++ b/DB/src/main/java/io/deephaven/db/v2/SwapListener.java @@ -1,13 +1,12 @@ package io.deephaven.db.v2; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.live.NotificationQueue; import io.deephaven.db.v2.utils.Index; public class SwapListener extends SwapListenerBase implements Listener { - public SwapListener(Logger log, BaseTable sourceTable) { - super(log, sourceTable); + public SwapListener(BaseTable sourceTable) { + super(sourceTable); } @Override diff --git a/DB/src/main/java/io/deephaven/db/v2/SwapListenerBase.java b/DB/src/main/java/io/deephaven/db/v2/SwapListenerBase.java index 81a744442a0..c77c8b63728 100644 --- a/DB/src/main/java/io/deephaven/db/v2/SwapListenerBase.java +++ b/DB/src/main/java/io/deephaven/db/v2/SwapListenerBase.java @@ -2,6 +2,7 @@ import io.deephaven.base.log.LogOutput; import io.deephaven.configuration.Configuration; +import io.deephaven.internal.log.LoggerFactory; import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.live.NotificationQueue; import io.deephaven.db.tables.live.NullIndexUpdateNotification; @@ -32,7 +33,7 @@ public abstract class SwapListenerBase extends Liveness protected static final boolean DEBUG = Configuration.getInstance().getBooleanWithDefault("SwapListener.debug", false); static final boolean DEBUG_NOTIFICATIONS = Configuration.getInstance().getBooleanWithDefault("SwapListener.debugNotifications", false); - final Logger log; + private static final Logger log = LoggerFactory.getLogger(SwapListenerBase.class); /** * The listener that will be called if this operation is successful. If we have a successful snapshot, then success is set to true. @@ -51,8 +52,7 @@ public abstract class SwapListenerBase extends Liveness */ final BaseTable sourceTable; - public SwapListenerBase(final Logger log, final BaseTable sourceTable) { - this.log = log; + public SwapListenerBase(final BaseTable sourceTable) { this.sourceTable = sourceTable; manage(sourceTable); } diff --git a/DB/src/main/java/io/deephaven/db/v2/TreeTableFilter.java b/DB/src/main/java/io/deephaven/db/v2/TreeTableFilter.java index a30f2cf7c7b..e1336771f85 100644 --- a/DB/src/main/java/io/deephaven/db/v2/TreeTableFilter.java +++ b/DB/src/main/java/io/deephaven/db/v2/TreeTableFilter.java @@ -2,6 +2,7 @@ import io.deephaven.base.Function; import io.deephaven.base.verify.Assert; +import io.deephaven.internal.log.LoggerFactory; import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.TableDefinition; @@ -38,13 +39,13 @@ public class TreeTableFilter implements Function.Unary, MemoizedOperationKey.Provider { private static final boolean DEBUG = io.deephaven.configuration.Configuration.getInstance().getBooleanWithDefault("TreeTableFilter.debug", false); - private final Logger log; + private static final Logger log = LoggerFactory.getLogger(TreeTableFilter.class); + private final SelectFilter[] filters; private final TableDefinition origTableDefinition; - private TreeTableFilter(Logger log, Table source, SelectFilter[] filters) { + private TreeTableFilter(Table source, SelectFilter[] filters) { this.filters = filters; - this.log = log; this.origTableDefinition = source.getDefinition(); for (final SelectFilter filter : filters) { @@ -123,7 +124,7 @@ private State(Table table, TableDefinition origTableDefinition) { idSource = source.getColumnSource(treeTableInfo.idColumn); if (source.isRefreshing()) { - swapListener = new SwapListenerWithRLL(log, source, reverseLookupListener); + swapListener = new SwapListenerWithRLL(source, reverseLookupListener); source.listenForUpdates(swapListener); ConstructSnapshot.callDataSnapshotFunction(System.identityHashCode(source)+": ", swapListener.makeSnapshotControl(), @@ -468,14 +469,12 @@ public int hashCode() { private static final class SwapListenerWithRLL extends ShiftAwareSwapListener { private final ReverseLookupListener rll; - private final Logger log; private long rllLastNotificationStep; - SwapListenerWithRLL(Logger log, BaseTable sourceTable, ReverseLookupListener rll) { - super(log, sourceTable); + SwapListenerWithRLL(BaseTable sourceTable, ReverseLookupListener rll) { + super(sourceTable); this.rll = rll; - this.log = log; } @Override @@ -574,19 +573,19 @@ public static Table toTreeTable(Table rawTable, Table originalTree) { return rawTable.treeTable(treeTableInfo.idColumn, treeTableInfo.parentColumn); } - public static Table rawFilterTree(Logger log, Table tree, String... filters) { - return rawFilterTree(log, tree, SelectFilterFactory.getExpressions(filters)); + public static Table rawFilterTree(Table tree, String... filters) { + return rawFilterTree(tree, SelectFilterFactory.getExpressions(filters)); } - public static Table rawFilterTree(Logger log, Table tree, SelectFilter[] filters) { - return tree.apply(new TreeTableFilter(log, tree, filters)); + public static Table rawFilterTree(Table tree, SelectFilter[] filters) { + return tree.apply(new TreeTableFilter(tree, filters)); } - public static Table filterTree(Logger log, Table tree, String... filters) { - return filterTree(log, tree, SelectFilterFactory.getExpressions(filters)); + public static Table filterTree(Table tree, String... filters) { + return filterTree(tree, SelectFilterFactory.getExpressions(filters)); } - public static Table filterTree(Logger log, Table tree, SelectFilter[] filters) { - return toTreeTable(rawFilterTree(log, tree, filters), tree); + public static Table filterTree(Table tree, SelectFilter[] filters) { + return toTreeTable(rawFilterTree(tree, filters), tree); } } diff --git a/DB/src/main/java/io/deephaven/db/v2/WouldMatchOperation.java b/DB/src/main/java/io/deephaven/db/v2/WouldMatchOperation.java index e109b565faa..edcb4c370d1 100644 --- a/DB/src/main/java/io/deephaven/db/v2/WouldMatchOperation.java +++ b/DB/src/main/java/io/deephaven/db/v2/WouldMatchOperation.java @@ -2,7 +2,6 @@ import io.deephaven.base.verify.Require; import io.deephaven.datastructures.util.CollectionUtil; -import io.deephaven.io.logger.Logger; import io.deephaven.db.exceptions.UncheckedTableException; import io.deephaven.db.tables.live.NotificationQueue; import io.deephaven.db.tables.select.WouldMatchPair; @@ -33,7 +32,6 @@ */ public class WouldMatchOperation implements QueryTable.MemoizableOperation { private static final ReadOnlyIndex EMPTY_INDEX = Index.FACTORY.getEmptyIndex(); - private final Logger log; private final List matchColumns; private final QueryTable parent; private QueryTable resultTable; @@ -57,8 +55,7 @@ SelectFilter getFilter() { } } - WouldMatchOperation(Logger log, QueryTable parent, WouldMatchPair... filters) { - this.log = log; + WouldMatchOperation(QueryTable parent, WouldMatchPair... filters) { this.parent = parent; matchColumns = Arrays.stream(filters).map(ColumnHolder::new).collect(Collectors.toList()); @@ -136,7 +133,7 @@ public Result initialize(boolean usePrev, long beforeClock) { if (parent.isRefreshing()) { // If we're refreshing, our final listener needs to handle upstream updates from a recorder. final ListenerRecorder recorder = new ListenerRecorder("where(" + makeDescription() + ")", parent, resultTable); - final Listener listener = new Listener(log, recorder, dependencies); + final Listener listener = new Listener(recorder, dependencies); recorder.setMergedListener(listener); eventualMergedListener = listener; @@ -145,7 +142,7 @@ public Result initialize(boolean usePrev, long beforeClock) { // If not, then we still need to update if any of our filters request updates. We'll use the // merge listener to handle that. Note that the filters themselves should set the table to // refreshing. - eventualMergedListener = new StaticListener(log, dependencies); + eventualMergedListener = new StaticListener(dependencies); } if (eventualMergedListener != null) { @@ -170,11 +167,9 @@ public MemoizedOperationKey getMemoizedOperationKey() { private class Listener extends MergedListener { final ListenerRecorder recorder; - Listener(@NotNull Logger log, - @NotNull ListenerRecorder recorder, + Listener(@NotNull ListenerRecorder recorder, @NotNull List dependencies) { - super(log, - Collections.singletonList(recorder), + super(Collections.singletonList(recorder), dependencies, "merge(" + makeDescription() + ")", resultTable); @@ -215,10 +210,8 @@ protected void process() { * * the parent table is static (not ticking). */ private class StaticListener extends MergedListener { - StaticListener(@NotNull Logger log, - @NotNull List dependencies) { - super(log, - Collections.emptyList(), + StaticListener(@NotNull List dependencies) { + super(Collections.emptyList(), dependencies, "wouldMatch(" + makeDescription() + ")", resultTable); diff --git a/DB/src/main/java/io/deephaven/db/v2/join/BucketedChunkedAjMergedListener.java b/DB/src/main/java/io/deephaven/db/v2/join/BucketedChunkedAjMergedListener.java index 5733dbf12b6..e9708909bf2 100644 --- a/DB/src/main/java/io/deephaven/db/v2/join/BucketedChunkedAjMergedListener.java +++ b/DB/src/main/java/io/deephaven/db/v2/join/BucketedChunkedAjMergedListener.java @@ -1,7 +1,6 @@ package io.deephaven.db.v2.join; import io.deephaven.base.verify.Assert; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.SortingOrder; import io.deephaven.db.tables.select.MatchPair; import io.deephaven.db.v2.*; @@ -68,8 +67,7 @@ public class BucketedChunkedAjMergedListener extends MergedListener { private final ObjectArraySource sequentialBuilders = new ObjectArraySource<>(Index.SequentialBuilder.class); private final LongArraySource slots = new LongArraySource(); - public BucketedChunkedAjMergedListener(Logger log, - JoinListenerRecorder leftRecorder, + public BucketedChunkedAjMergedListener(JoinListenerRecorder leftRecorder, JoinListenerRecorder rightRecorder, String listenerDescription, QueryTable result, @@ -88,7 +86,7 @@ public BucketedChunkedAjMergedListener(Logger log, SsaSsaStamp ssaSsaStamp, JoinControl control, RightIncrementalChunkedAsOfJoinStateManager asOfJoinStateManager, RedirectionIndex redirectionIndex) { - super(log, Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result); + super(Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result); this.leftRecorder = leftRecorder; this.rightRecorder = rightRecorder; this.leftTable = leftTable; diff --git a/DB/src/main/java/io/deephaven/db/v2/join/ZeroKeyChunkedAjMergedListener.java b/DB/src/main/java/io/deephaven/db/v2/join/ZeroKeyChunkedAjMergedListener.java index 60a70f4ed14..d0fb37620b7 100644 --- a/DB/src/main/java/io/deephaven/db/v2/join/ZeroKeyChunkedAjMergedListener.java +++ b/DB/src/main/java/io/deephaven/db/v2/join/ZeroKeyChunkedAjMergedListener.java @@ -1,6 +1,5 @@ package io.deephaven.db.v2.join; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.SortingOrder; import io.deephaven.db.tables.select.MatchPair; import io.deephaven.db.v2.*; @@ -52,8 +51,7 @@ public class ZeroKeyChunkedAjMergedListener extends MergedListener { private final ModifiedColumnSet resultModifiedColumnSet; - public ZeroKeyChunkedAjMergedListener(Logger log, - JoinListenerRecorder leftRecorder, + public ZeroKeyChunkedAjMergedListener(JoinListenerRecorder leftRecorder, JoinListenerRecorder rightRecorder, String listenerDescription, QueryTable result, @@ -70,7 +68,7 @@ public ZeroKeyChunkedAjMergedListener(Logger log, SegmentedSortedArray rightSsa, RedirectionIndex redirectionIndex, JoinControl joinControl) { - super(log, Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result); + super(Arrays.asList(leftRecorder, rightRecorder), Collections.emptyList(), listenerDescription, result); this.leftRecorder = leftRecorder; this.rightRecorder = rightRecorder; this.leftTable = leftTable; diff --git a/DB/src/main/java/io/deephaven/db/v2/snapshot/SnapshotIncrementalListener.java b/DB/src/main/java/io/deephaven/db/v2/snapshot/SnapshotIncrementalListener.java index a522c58b944..e6f5bcc7c77 100644 --- a/DB/src/main/java/io/deephaven/db/v2/snapshot/SnapshotIncrementalListener.java +++ b/DB/src/main/java/io/deephaven/db/v2/snapshot/SnapshotIncrementalListener.java @@ -1,6 +1,5 @@ package io.deephaven.db.v2.snapshot; -import io.deephaven.io.logger.Logger; import io.deephaven.db.v2.ListenerRecorder; import io.deephaven.db.v2.MergedListener; import io.deephaven.db.v2.QueryTable; @@ -26,9 +25,9 @@ public class SnapshotIncrementalListener extends MergedListener { private final Index lastRightIndex; private boolean firstSnapshot = true; - public SnapshotIncrementalListener(Logger log, QueryTable triggerTable, QueryTable resultTable, Map resultColumns, + public SnapshotIncrementalListener(QueryTable triggerTable, QueryTable resultTable, Map resultColumns, ListenerRecorder rightListener, ListenerRecorder leftListener, QueryTable rightTable, Map leftColumns) { - super(log, Arrays.asList(rightListener, leftListener), Collections.emptyList(), "snapshotIncremental", resultTable); + super(Arrays.asList(rightListener, leftListener), Collections.emptyList(), "snapshotIncremental", resultTable); this.triggerTable = triggerTable; this.resultTable = resultTable; this.resultColumns = resultColumns; diff --git a/DB/src/main/java/io/deephaven/db/v2/sources/UnionSourceManager.java b/DB/src/main/java/io/deephaven/db/v2/sources/UnionSourceManager.java index e6e1ad6495f..539dfcab04c 100644 --- a/DB/src/main/java/io/deephaven/db/v2/sources/UnionSourceManager.java +++ b/DB/src/main/java/io/deephaven/db/v2/sources/UnionSourceManager.java @@ -6,7 +6,6 @@ import io.deephaven.base.verify.Assert; import io.deephaven.base.verify.Require; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.ColumnDefinition; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.TableDefinition; @@ -47,7 +46,7 @@ public class UnionSourceManager { private UpdateCommitter prevFlusher = null; - public UnionSourceManager(Logger log, TableDefinition tableDefinition, @Nullable NotificationQueue.Dependency parentDependency){ + public UnionSourceManager(TableDefinition tableDefinition, @Nullable NotificationQueue.Dependency parentDependency){ // noinspection unchecked sources = tableDefinition.getColumnList().stream() .map((cd) -> new UnionColumnSource(cd.getDataType(), cd.getComponentType(), unionRedirection, this)) @@ -59,7 +58,7 @@ public UnionSourceManager(Logger log, TableDefinition tableDefinition, @Nullable result = new QueryTable(index, getColumnSources()); modifiedColumnSet = result.newModifiedColumnSet(names); - mergedListener = new MergedUnionListener(log, listeners, "TableTools.merge()", result); + mergedListener = new MergedUnionListener(listeners, "TableTools.merge()", result); } /** @@ -207,8 +206,8 @@ class UnionListenerRecorder extends ListenerRecorder { } class MergedUnionListener extends MergedListener { - MergedUnionListener(Logger log, Collection recorders, String listenerDescription, QueryTable result) { - super(log, recorders, Collections.emptyList(), listenerDescription, result); + MergedUnionListener(Collection recorders, String listenerDescription, QueryTable result) { + super(recorders, Collections.emptyList(), listenerDescription, result); } @Override diff --git a/DB/src/main/java/io/deephaven/db/v2/utils/SyncTableFilter.java b/DB/src/main/java/io/deephaven/db/v2/utils/SyncTableFilter.java index b411ea03670..11b223d8293 100644 --- a/DB/src/main/java/io/deephaven/db/v2/utils/SyncTableFilter.java +++ b/DB/src/main/java/io/deephaven/db/v2/utils/SyncTableFilter.java @@ -9,7 +9,6 @@ import io.deephaven.base.verify.Assert; import io.deephaven.configuration.Configuration; import io.deephaven.datastructures.util.SmartKey; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.live.LiveTableMonitor; import io.deephaven.db.tables.live.NotificationQueue; @@ -189,7 +188,7 @@ private SyncTableFilter(final List tables) { class MergedSyncListener extends io.deephaven.db.v2.MergedListener { MergedSyncListener(final QueryTable dummyResult) { - super(Logger.NULL, recorders, Collections.emptyList(), "SyncTableListener", dummyResult); + super(recorders, Collections.emptyList(), "SyncTableListener", dummyResult); } @Override diff --git a/DB/src/test/java/io/deephaven/db/tables/utils/TestWindowCheck.java b/DB/src/test/java/io/deephaven/db/tables/utils/TestWindowCheck.java index f1aa5908ad4..64a6b4a8987 100644 --- a/DB/src/test/java/io/deephaven/db/tables/utils/TestWindowCheck.java +++ b/DB/src/test/java/io/deephaven/db/tables/utils/TestWindowCheck.java @@ -1,7 +1,6 @@ package io.deephaven.db.tables.utils; import io.deephaven.base.Pair; -import io.deephaven.io.logger.StreamLoggerImpl; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.live.LiveTableMonitor; import io.deephaven.db.v2.*; @@ -128,7 +127,7 @@ public void testWindowCheckEmptyInitial() { final DBDateTime[] emptyDateTimeArray = new DBDateTime[0]; final Table tableToCheck = testRefreshingTable(i(), c("Timestamp", emptyDateTimeArray), intCol("Sentinel")); - final Pair windowed = LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> WindowCheck.addTimeWindowInternal(new StreamLoggerImpl(), timeProvider, tableToCheck, "Timestamp", DBTimeUtils.SECOND * 60, "InWindow", false)); + final Pair windowed = LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> WindowCheck.addTimeWindowInternal(timeProvider, tableToCheck, "Timestamp", DBTimeUtils.SECOND * 60, "InWindow", false)); TableTools.showWithIndex(windowed.first); @@ -177,7 +176,7 @@ public void onFailureInternal(Throwable originalException, UpdatePerformanceTrac this.table = table; this.timeProvider = timeProvider; windowNanos = 300 * DBTimeUtils.SECOND; - windowed = WindowCheck.addTimeWindowInternal(new StreamLoggerImpl(), timeProvider, table, "Timestamp", windowNanos, "InWindow", false); + windowed = WindowCheck.addTimeWindowInternal(timeProvider, table, "Timestamp", windowNanos, "InWindow", false); validator = TableUpdateValidator.make((QueryTable)windowed.first); ((QueryTable)windowed.first).listenForUpdates(windowedFailureListener); diff --git a/DB/src/test/java/io/deephaven/db/v2/QueryFactory.java b/DB/src/test/java/io/deephaven/db/v2/QueryFactory.java index cf850b32e59..f07f4fab96b 100644 --- a/DB/src/test/java/io/deephaven/db/v2/QueryFactory.java +++ b/DB/src/test/java/io/deephaven/db/v2/QueryFactory.java @@ -250,7 +250,7 @@ private void addSelectOperation(int opNum, StringBuilder opChain, String nameSee final String nextTableName = "table" + nameSeed + "_" + opNum; final String lastTableName = "table" + nameSeed + "_" + (opNum - 1); opChain.append(nextTableName).append("prime = "); - opChain.append("io.deephaven.db.v2.SelectOverheadLimiter.clampSelectOverhead(log, ").append(lastTableName).append(", 10.0d);\n"); + opChain.append("io.deephaven.db.v2.SelectOverheadLimiter.clampSelectOverhead(").append(lastTableName).append(", 10.0d);\n"); opChain.append(nextTableName).append(" = ").append(nextTableName).append("prime").append(".select();\n"); } @@ -816,7 +816,7 @@ public String getTablePreamble(Long tableSeed) { "\tSystem.out.println(\"column: \"+colNum+\"[Seed] \" + seed);\n" + "\tcolumnRandoms[colNum] = new Random(seed);\n" + "}\n\n" + - "tt = db.timeTable(\"00:00:00.1\");" + + "tt = timeTable(\"00:00:00.1\");" + "tickingValues = tt.update(\n" + "\"MyString=new String(`a`+i)\",\n" + "\"MyInt=new Integer(i)\",\n" + diff --git a/DB/src/test/java/io/deephaven/db/v2/QueryTableAjTest.java b/DB/src/test/java/io/deephaven/db/v2/QueryTableAjTest.java index 3e10fcff0b1..667e949d08d 100644 --- a/DB/src/test/java/io/deephaven/db/v2/QueryTableAjTest.java +++ b/DB/src/test/java/io/deephaven/db/v2/QueryTableAjTest.java @@ -502,7 +502,7 @@ private void testAjRandomStaticOverflow(int seed, int leftSize, int rightSize) { new TstUtils.SortedIntGenerator(0, 100000), new TstUtils.IntGenerator(20_000_000, 20_010_000))); - final Table result = AsOfJoinHelper.asOfJoin(log, QueryTableJoinTest.SMALL_LEFT_CONTROL, leftTable, (QueryTable)rightTable.reverse(), MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, true); + final Table result = AsOfJoinHelper.asOfJoin(QueryTableJoinTest.SMALL_LEFT_CONTROL, leftTable, (QueryTable)rightTable.reverse(), MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, true); final TableMap bucketResults = result.byExternal("Bucket"); final TableMap leftBucket = leftTable.byExternal("Bucket"); @@ -822,28 +822,28 @@ private void testAjRandomIncrementalWithInitial(int seed,int leftNodeSize, int r final EvalNuggetInterface [] en = Stream.concat(Stream.concat(!withZeroKeys ? Stream.empty() : Stream.concat( Stream.of( // aj - EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(log, control, leftTable, rightSorted, MatchPairFactory.getExpressions("LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Ascending, false)), + EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(control, leftTable, rightSorted, MatchPairFactory.getExpressions("LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Ascending, false)), // < aj - EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(log, control, leftTable, rightSorted, AjMatchPairFactory.getExpressions(false, "LeftStamp AsOfJoinHelper.asOfJoin(control, leftTable, rightSorted, AjMatchPairFactory.getExpressions(false, "LeftStamp AsOfJoinHelper.asOfJoin(log, control, leftTable, rightReversed, MatchPairFactory.getExpressions("LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, false)), + EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(control, leftTable, rightReversed, MatchPairFactory.getExpressions("LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, false)), // > raj - EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(log, control, leftTable, rightReversed, AjMatchPairFactory.getExpressions(true, "LeftStamp>RightStamp").first, MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, true)) + EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(control, leftTable, rightReversed, AjMatchPairFactory.getExpressions(true, "LeftStamp>RightStamp").first, MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, true)) )), !withBuckets ? Stream.empty() : Stream.of( // aj, with a bucket - EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(log, control, leftTable, rightSorted, MatchPairFactory.getExpressions("Truthiness", "Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Ascending, false)), - EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(log, control, leftTable, rightSorted, MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Ascending, false)), + EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(control, leftTable, rightSorted, MatchPairFactory.getExpressions("Truthiness", "Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Ascending, false)), + EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(control, leftTable, rightSorted, MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Ascending, false)), // < aj, with a bucket - EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(log, control, leftTable, rightSorted, AjMatchPairFactory.getExpressions(false, "Bucket", "LeftStamp AsOfJoinHelper.asOfJoin(control, leftTable, rightSorted, AjMatchPairFactory.getExpressions(false, "Bucket", "LeftStamp AsOfJoinHelper.asOfJoin(log, control, leftTable, rightReversed, MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, false)), + EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(control, leftTable, rightReversed, MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, false)), // > raj, with a bucket - EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(log, control, leftTable, rightReversed, AjMatchPairFactory.getExpressions(true, "Bucket", "LeftStamp>RightStamp").first, MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, true))) + EvalNugget.from(() -> AsOfJoinHelper.asOfJoin(control, leftTable, rightReversed, AjMatchPairFactory.getExpressions(true, "Bucket", "LeftStamp>RightStamp").first, MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), SortingOrder.Descending, true))) ).toArray(EvalNuggetInterface[]::new); for (int step = 0; step < maxSteps; step++) { @@ -876,7 +876,7 @@ private void doInitialAjComparison(QueryTable leftTable, QueryTable rightTable, } try (final SafeCloseable ignored = LivenessScopeStack.open()) { - final Table refreshingResult = AsOfJoinHelper.asOfJoin(log, control, leftTable, reverse ? ((QueryTable)rightTable.reverse()) : rightTable, AjMatchPairFactory.getExpressions(reverse, columnsToMatch.split(",")).first, MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), reverse ? SortingOrder.Descending : SortingOrder.Ascending, disallowMatch); + final Table refreshingResult = AsOfJoinHelper.asOfJoin(control, leftTable, reverse ? ((QueryTable)rightTable.reverse()) : rightTable, AjMatchPairFactory.getExpressions(reverse, columnsToMatch.split(",")).first, MatchPairFactory.getExpressions("RightStamp", "RightSentinel"), reverse ? SortingOrder.Descending : SortingOrder.Ascending, disallowMatch); if (LiveTableTestCase.printTableUpdates) { System.out.println("Refreshing: "); @@ -1017,7 +1017,7 @@ public void testAjRandomLeftIncrementalRightStaticOverflow() { new EvalNugget() { @Override protected Table e() { - return AsOfJoinHelper.asOfJoin(log, QueryTableJoinTest.SMALL_RIGHT_CONTROL, leftTable, rightTable, MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightSentinel"), SortingOrder.Ascending, false); + return AsOfJoinHelper.asOfJoin(QueryTableJoinTest.SMALL_RIGHT_CONTROL, leftTable, rightTable, MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightSentinel"), SortingOrder.Ascending, false); } }, }; @@ -1213,7 +1213,7 @@ public void testIds6898() { new EvalNugget() { @Override protected Table e() { - return AsOfJoinHelper.asOfJoin(log, QueryTableJoinTest.SMALL_RIGHT_CONTROL, (QueryTable)leftTable.sort("LeftStamp"), rightTable, MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightSentinel"), SortingOrder.Ascending, false); + return AsOfJoinHelper.asOfJoin(QueryTableJoinTest.SMALL_RIGHT_CONTROL, (QueryTable)leftTable.sort("LeftStamp"), rightTable, MatchPairFactory.getExpressions("Bucket", "LeftStamp=RightStamp"), MatchPairFactory.getExpressions("RightSentinel"), SortingOrder.Ascending, false); } }, }; diff --git a/DB/src/test/java/io/deephaven/db/v2/QueryTableCrossJoinTestBase.java b/DB/src/test/java/io/deephaven/db/v2/QueryTableCrossJoinTestBase.java index 2560391b320..735d676277f 100644 --- a/DB/src/test/java/io/deephaven/db/v2/QueryTableCrossJoinTestBase.java +++ b/DB/src/test/java/io/deephaven/db/v2/QueryTableCrossJoinTestBase.java @@ -13,7 +13,6 @@ import io.deephaven.db.v2.sources.chunk.ChunkType; import io.deephaven.db.v2.sources.chunk.ResettableWritableChunk; import io.deephaven.db.v2.sources.chunk.WritableIntChunk; -import io.deephaven.db.v2.sources.chunk.util.pools.ChunkPoolReleaseTracking; import io.deephaven.db.v2.utils.Index; import io.deephaven.db.v2.utils.IndexShiftData; import io.deephaven.test.types.OutOfBandTest; @@ -424,9 +423,9 @@ int initialBuildSize() { }; final EvalNugget[] en = new EvalNugget[]{ - EvalNugget.from(() -> CrossJoinHelper.join(QueryTable.log, leftNotTicking, rightTicking, MatchPairFactory.getExpressions("ltSym=rtSym"), MatchPair.ZERO_LENGTH_MATCH_PAIR_ARRAY, numRightBitsToReserve, control)), - EvalNugget.from(() -> CrossJoinHelper.join(QueryTable.log, leftTicking, rightTicking, MatchPairFactory.getExpressions("ltSym=rtSym"), MatchPair.ZERO_LENGTH_MATCH_PAIR_ARRAY, numRightBitsToReserve, control)), - EvalNugget.from(() -> CrossJoinHelper.join(QueryTable.log, leftShifting, rightTicking, MatchPairFactory.getExpressions("ltSym=rtSym"), MatchPair.ZERO_LENGTH_MATCH_PAIR_ARRAY, numRightBitsToReserve, control)), + EvalNugget.from(() -> CrossJoinHelper.join(leftNotTicking, rightTicking, MatchPairFactory.getExpressions("ltSym=rtSym"), MatchPair.ZERO_LENGTH_MATCH_PAIR_ARRAY, numRightBitsToReserve, control)), + EvalNugget.from(() -> CrossJoinHelper.join(leftTicking, rightTicking, MatchPairFactory.getExpressions("ltSym=rtSym"), MatchPair.ZERO_LENGTH_MATCH_PAIR_ARRAY, numRightBitsToReserve, control)), + EvalNugget.from(() -> CrossJoinHelper.join(leftShifting, rightTicking, MatchPairFactory.getExpressions("ltSym=rtSym"), MatchPair.ZERO_LENGTH_MATCH_PAIR_ARRAY, numRightBitsToReserve, control)), }; final int updateSize = (int)Math.ceil(Math.sqrt(numGroups)); @@ -561,7 +560,7 @@ int initialBuildSize() { }; final EvalNugget[] en = new EvalNugget[]{ - EvalNugget.from(() -> CrossJoinHelper.join(QueryTable.log, leftTicking, rightTicking, MatchPairFactory.getExpressions("intCol"), MatchPair.ZERO_LENGTH_MATCH_PAIR_ARRAY, numRightBitsToReserve, control)), + EvalNugget.from(() -> CrossJoinHelper.join(leftTicking, rightTicking, MatchPairFactory.getExpressions("intCol"), MatchPair.ZERO_LENGTH_MATCH_PAIR_ARRAY, numRightBitsToReserve, control)), }; if (LiveTableTestCase.printTableUpdates) { diff --git a/DB/src/test/java/io/deephaven/db/v2/QueryTableNaturalJoinTest.java b/DB/src/test/java/io/deephaven/db/v2/QueryTableNaturalJoinTest.java index bd680f5089a..a8b2509eeee 100644 --- a/DB/src/test/java/io/deephaven/db/v2/QueryTableNaturalJoinTest.java +++ b/DB/src/test/java/io/deephaven/db/v2/QueryTableNaturalJoinTest.java @@ -249,17 +249,17 @@ private static void testNaturalJoinIncremental(boolean leftStatic, boolean right final EvalNugget[] en = new EvalNugget[]{ new EvalNugget() { public Table e() { - return NaturalJoinHelper.naturalJoin(log, leftTable, rightTable, MatchPairFactory.getExpressions("I1"), MatchPairFactory.getExpressions("LI1=I1","LC1=C1","LC2=C2"), false, control); + return NaturalJoinHelper.naturalJoin(leftTable, rightTable, MatchPairFactory.getExpressions("I1"), MatchPairFactory.getExpressions("LI1=I1","LC1=C1","LC2=C2"), false, control); } }, new EvalNugget() { public Table e() { - return NaturalJoinHelper.naturalJoin(log, leftTable, rightTable, MatchPairFactory.getExpressions("C1","I1"), MatchPairFactory.getExpressions("LC2=C2"), false, control); + return NaturalJoinHelper.naturalJoin(leftTable, rightTable, MatchPairFactory.getExpressions("C1","I1"), MatchPairFactory.getExpressions("LC2=C2"), false, control); } }, new EvalNugget() { public Table e() { - return NaturalJoinHelper.naturalJoin(log, leftTable, (QueryTable)rightTable.update("Exists=true"), MatchPairFactory.getExpressions("C1","C2","I1"), MatchPairFactory.getExpressions("Exists"), false, control); + return NaturalJoinHelper.naturalJoin(leftTable, (QueryTable)rightTable.update("Exists=true"), MatchPairFactory.getExpressions("C1","C2","I1"), MatchPairFactory.getExpressions("Exists"), false, control); } }, }; diff --git a/DB/src/test/java/io/deephaven/db/v2/QueryTableStaticNaturalJoinRandomTest.java b/DB/src/test/java/io/deephaven/db/v2/QueryTableStaticNaturalJoinRandomTest.java index 210b7a4caca..ce8ef24d5a6 100644 --- a/DB/src/test/java/io/deephaven/db/v2/QueryTableStaticNaturalJoinRandomTest.java +++ b/DB/src/test/java/io/deephaven/db/v2/QueryTableStaticNaturalJoinRandomTest.java @@ -188,7 +188,7 @@ private static void testNaturalJoinRandomStatic(int seed, int leftSize, int righ if (control == null) { joined = leftJoinTable.naturalJoin(rightJoinTable, matchKeys, "RightSentinel"); } else { - joined = NaturalJoinHelper.naturalJoin(log, (QueryTable)leftJoinTable, (QueryTable) rightJoinTable, MatchPairFactory.getExpressions(StringUtils.splitToCollection(matchKeys)), MatchPairFactory.getExpressions("RightSentinel"), false, control); + joined = NaturalJoinHelper.naturalJoin((QueryTable)leftJoinTable, (QueryTable) rightJoinTable, MatchPairFactory.getExpressions(StringUtils.splitToCollection(matchKeys)), MatchPairFactory.getExpressions("RightSentinel"), false, control); } final Table updated = updateFixup.apply(leftTable.update(updateString)); diff --git a/DB/src/test/java/io/deephaven/db/v2/QueryTableTreeTest.java b/DB/src/test/java/io/deephaven/db/v2/QueryTableTreeTest.java index 2a2f4363c29..785e56d5be1 100644 --- a/DB/src/test/java/io/deephaven/db/v2/QueryTableTreeTest.java +++ b/DB/src/test/java/io/deephaven/db/v2/QueryTableTreeTest.java @@ -67,11 +67,11 @@ public void testMemoize() { final boolean old = QueryTable.setMemoizeResults(true); try { - testMemoize(tree, t -> TreeTableFilter.rawFilterTree(Logger.NULL, t, "Sym in `AAPL`, `TSLA`")); - testMemoize(tree, t -> TreeTableFilter.rawFilterTree(Logger.NULL, t, "Sym in `AAPL`, `TSLA`", "Sentinel == 500000000")); - testNoMemoize(tree, t -> TreeTableFilter.rawFilterTree(Logger.NULL, t, "Sentinel > Sentinel2/4")); - testNoMemoize(tree, t -> TreeTableFilter.rawFilterTree(Logger.NULL, t, "Sym in `AAPL`, `TSLA`"), - t -> TreeTableFilter.rawFilterTree(Logger.NULL, t, "Sym in `AAPL`")); + testMemoize(tree, t -> TreeTableFilter.rawFilterTree(t, "Sym in `AAPL`, `TSLA`")); + testMemoize(tree, t -> TreeTableFilter.rawFilterTree(t, "Sym in `AAPL`, `TSLA`", "Sentinel == 500000000")); + testNoMemoize(tree, t -> TreeTableFilter.rawFilterTree(t, "Sentinel > Sentinel2/4")); + testNoMemoize(tree, t -> TreeTableFilter.rawFilterTree(t, "Sym in `AAPL`, `TSLA`"), + t -> TreeTableFilter.rawFilterTree(t, "Sym in `AAPL`")); } finally { QueryTable.setMemoizeResults(old); } @@ -228,14 +228,14 @@ public void testConcurrentInstantiation() throws ExecutionException, Interrupted LiveTableMonitor.DEFAULT.startCycleForUnitTests(); - final Table backwards1 = pool.submit(() -> TreeTableFilter.rawFilterTree(log, treed1, "!isNull(Extra)").sortDescending("Extra")).get(); + final Table backwards1 = pool.submit(() -> TreeTableFilter.rawFilterTree(treed1, "!isNull(Extra)").sortDescending("Extra")).get(); final Table backwardsTree1a = pool.submit(() -> backwards1.treeTable("Sentinel", "Parent")).get(); final Table treed4 = pool.submit(doTree::get).get(); TstUtils.addToTable(source, i(12), c("Sentinel", 12), c("Parent", 11), c("Extra", "l")); - final Table backwards2 = pool.submit(() -> TreeTableFilter.rawFilterTree(log, treed1, "!isNull(Extra)").sortDescending("Extra")).get(); + final Table backwards2 = pool.submit(() -> TreeTableFilter.rawFilterTree(treed1, "!isNull(Extra)").sortDescending("Extra")).get(); final Table backwardsTree1b = pool.submit(() -> backwards1.treeTable("Sentinel", "Parent")).get(); final Table backwardsTree2a = pool.submit(() -> backwards2.treeTable("Sentinel", "Parent")).get(); @@ -256,7 +256,7 @@ public void testConcurrentInstantiation() throws ExecutionException, Interrupted final Table backwardsTree1c = pool.submit(() -> backwards1.treeTable("Sentinel", "Parent")).get(); final Table backwardsTree2b = pool.submit(() -> backwards2.treeTable("Sentinel", "Parent")).get(); - final Table backwards3 = pool.submit(() -> TreeTableFilter.rawFilterTree(log, treed1, "!isNull(Extra)").sortDescending("Extra")).get(); + final Table backwards3 = pool.submit(() -> TreeTableFilter.rawFilterTree(treed1, "!isNull(Extra)").sortDescending("Extra")).get(); final Table backwardsTree3 = pool.submit(() -> backwards3.treeTable("Sentinel", "Parent")).get(); final Table root1a = map1.get(null); @@ -410,7 +410,7 @@ public void testTreeTableStaticFilter() { final String hierarchicalColumnName = getHierarchicalColumnName(treed); assertEquals(2, treed.size()); - final Table filtered = TreeTableFilter.filterTree(Logger.NULL, treed, "Sentinel in 6, 11, 14"); + final Table filtered = TreeTableFilter.filterTree(treed, "Sentinel in 6, 11, 14"); TableTools.showWithIndex(filtered); assertEquals(1, filtered.size()); @@ -432,7 +432,7 @@ public void testTreeTableSimpleFilter() { assertEquals(2, treed.size()); System.out.println("Filtered."); - final Table filtered = TreeTableFilter.filterTree(Logger.NULL, treed, "Sentinel in 6, 11, 14"); + final Table filtered = TreeTableFilter.filterTree(treed, "Sentinel in 6, 11, 14"); TableTools.showWithIndex(filtered); assertEquals(1, filtered.size()); @@ -569,7 +569,7 @@ public void testTreeTableEdgeCases() { protected Table e() { return LiveTableMonitor.DEFAULT.exclusiveLock().computeLocked(() -> { final Table treed = source.treeTable("Sentinel", "Parent"); - return TreeTableFilter.rawFilterTree(Logger.NULL, treed, "Filter in 1"); + return TreeTableFilter.rawFilterTree(treed, "Filter in 1"); }); } }, @@ -956,10 +956,10 @@ protected Table e() { new TreeTableEvalNugget(prepared) { @Override protected Table e() { - return TreeTableFilter.filterTree(Logger.NULL, prepared.treeTable("ID", "Parent"), "Sentinel % 2 == 1"); + return TreeTableFilter.filterTree(prepared.treeTable("ID", "Parent"), "Sentinel % 2 == 1"); } }, - EvalNugget.from(() -> TreeTableFilter.rawFilterTree(Logger.NULL, prepared.treeTable("ID", "Parent"), "Sentinel % 2 == 1")), + EvalNugget.from(() -> TreeTableFilter.rawFilterTree(prepared.treeTable("ID", "Parent"), "Sentinel % 2 == 1")), }; final int maxSteps = numSteps.intValue(); @@ -1609,8 +1609,8 @@ public void testOrderTreeTable() { .update("treeid=new io.deephaven.datastructures.util.SmartKey(hid, hpos)", "parent=io.deephaven.db.v2.QueryTableTreeTest.getPrefix(hid, hpos)"); final Table ordersTree = orders.treeTable("treeid", "parent"); - final Table ordersFiltered = TreeTableFilter.filterTree(Logger.NULL, ordersTree, "rand > 0.8"); - final Table ordersFiltered2 = TreeTableFilter.filterTree(Logger.NULL, ordersTree, "rand > 0.1"); + final Table ordersFiltered = TreeTableFilter.filterTree(ordersTree, "rand > 0.8"); + final Table ordersFiltered2 = TreeTableFilter.filterTree(ordersTree, "rand > 0.1"); for (int step = 0; step < 100; ++step) { System.out.println("step = " + step); @@ -1691,8 +1691,8 @@ public void testOrderTreeTable() { LiveTableMonitor.DEFAULT.completeCycleForUnitTests(); final String hierarchicalColumnName = getHierarchicalColumnName(ordersFiltered); - doCompareWithChildrenForTrees("step = " + step, ordersFiltered, TreeTableFilter.filterTree(Logger.NULL, ordersTree, "rand > 0.8"), 0, maxLevel, hierarchicalColumnName, CollectionUtil.ZERO_LENGTH_STRING_ARRAY); - doCompareWithChildrenForTrees("step = " + step, ordersFiltered2, TreeTableFilter.filterTree(Logger.NULL, ordersTree, "rand > 0.1"), 0, maxLevel, hierarchicalColumnName, CollectionUtil.ZERO_LENGTH_STRING_ARRAY); + doCompareWithChildrenForTrees("step = " + step, ordersFiltered, TreeTableFilter.filterTree(ordersTree, "rand > 0.8"), 0, maxLevel, hierarchicalColumnName, CollectionUtil.ZERO_LENGTH_STRING_ARRAY); + doCompareWithChildrenForTrees("step = " + step, ordersFiltered2, TreeTableFilter.filterTree(ordersTree, "rand > 0.1"), 0, maxLevel, hierarchicalColumnName, CollectionUtil.ZERO_LENGTH_STRING_ARRAY); } } diff --git a/DB/src/test/java/io/deephaven/db/v2/SelectOverheadLimiter.java b/DB/src/test/java/io/deephaven/db/v2/SelectOverheadLimiter.java index a04194f26db..0e3585939d1 100644 --- a/DB/src/test/java/io/deephaven/db/v2/SelectOverheadLimiter.java +++ b/DB/src/test/java/io/deephaven/db/v2/SelectOverheadLimiter.java @@ -2,7 +2,6 @@ import io.deephaven.base.verify.Assert; import io.deephaven.datastructures.util.CollectionUtil; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.live.LiveTableMonitor; import io.deephaven.db.tables.live.NotificationQueue; @@ -19,7 +18,7 @@ /** * The table {@link Table#select} or {@link Table#update} and operations produce sparse sources as of Treasure. If you * have a sparse index, that means that you can have many blocks which only actually contain one or very few elements. - * The {@link #clampSelectOverhead(Logger, Table, double)} method is intended to precede a select or update operation, to + * The {@link #clampSelectOverhead(Table, double)} method is intended to precede a select or update operation, to * limit the amount of memory overhead allowed. For tables that are relatively dense, the original indices are * preserved. If the overhead exceeds the allowable factor, then the table is flattened before passing updates to * select. Once a table is made flat, it will not revert to it's original address space but rather remain flat. @@ -86,7 +85,7 @@ public void shift(long key, long shiftDelta) { } } - public static Table clampSelectOverhead(Logger log, Table input, double permittedOverhead) { + public static Table clampSelectOverhead(Table input, double permittedOverhead) { if (!input.isLive()) { return input.flatten(); } @@ -115,7 +114,7 @@ public static Table clampSelectOverhead(Logger log, Table input, double permitte final List recorders = Collections.synchronizedList(new ArrayList<>()); recorders.add(inputRecorder.getValue()); - final MergedListener mergedListener = new MergedListener(log, recorders, Collections.singletonList((NotificationQueue.Dependency)input), "clampSelectOverhead", result) { + final MergedListener mergedListener = new MergedListener(recorders, Collections.singletonList((NotificationQueue.Dependency)input), "clampSelectOverhead", result) { Table flatResult = null; ListenerRecorder flatRecorder; ModifiedColumnSet.Transformer flatTransformer; diff --git a/DB/src/test/java/io/deephaven/db/v2/TestConcurrentInstantiation.java b/DB/src/test/java/io/deephaven/db/v2/TestConcurrentInstantiation.java index 514f44f0f54..cfa50b2e808 100644 --- a/DB/src/test/java/io/deephaven/db/v2/TestConcurrentInstantiation.java +++ b/DB/src/test/java/io/deephaven/db/v2/TestConcurrentInstantiation.java @@ -3,7 +3,6 @@ import io.deephaven.base.Pair; import io.deephaven.base.SleepUtil; import io.deephaven.base.verify.Assert; -import io.deephaven.io.logger.Logger; import io.deephaven.db.tables.Table; import io.deephaven.db.tables.libs.QueryLibrary; import io.deephaven.db.tables.live.LiveTableMonitor; @@ -58,7 +57,7 @@ public void testTreeTableFilter() throws ExecutionException, InterruptedExceptio col("Parent", NULL_INT, NULL_INT, 1, 1, 2, 3, 5, 5, 3, 2)); final Table treed = LiveTableMonitor.DEFAULT.exclusiveLock().computeLocked(() -> source.treeTable("Sentinel", "Parent")); - final Callable
callable = () -> TreeTableFilter.rawFilterTree(Logger.NULL, treed, "Sentinel in 4, 6, 9, 11, 12, 13, 14, 15"); + final Callable
callable = () -> TreeTableFilter.rawFilterTree(treed, "Sentinel in 4, 6, 9, 11, 12, 13, 14, 15"); LiveTableMonitor.DEFAULT.startCycleForUnitTests(); final Table rawSorted = pool.submit(callable).get(); diff --git a/DB/src/test/java/io/deephaven/db/v2/TestSelectOverheadLimiter.java b/DB/src/test/java/io/deephaven/db/v2/TestSelectOverheadLimiter.java index 76d420238bc..3f54c728d61 100644 --- a/DB/src/test/java/io/deephaven/db/v2/TestSelectOverheadLimiter.java +++ b/DB/src/test/java/io/deephaven/db/v2/TestSelectOverheadLimiter.java @@ -21,7 +21,7 @@ public class TestSelectOverheadLimiter extends LiveTableTestCase { public void testSelectOverheadLimiter() { final QueryTable queryTable = TstUtils.testRefreshingTable(Index.FACTORY.getIndexByRange(0, 100)); final Table sentinelTable = queryTable.updateView("Sentinel=k"); - final Table densified = LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(new StreamLoggerImpl(), sentinelTable, 3.0)); + final Table densified = LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(sentinelTable, 3.0)); assertEquals(densified.getIndex(), sentinelTable.getIndex()); assertTableEquals(sentinelTable, densified); @@ -65,7 +65,7 @@ public void testSelectOverheadLimiter() { public void testShift() { final QueryTable queryTable = TstUtils.testRefreshingTable(Index.FACTORY.getIndexByRange(0, 100)); final Table sentinelTable = queryTable.updateView("Sentinel=ii"); - final Table densified = LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(new StreamLoggerImpl(), sentinelTable, 3.0)); + final Table densified = LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(sentinelTable, 3.0)); assertEquals(densified.getIndex(), sentinelTable.getIndex()); assertTableEquals(sentinelTable, densified); @@ -121,17 +121,15 @@ private void testByExternal(int seed) { final Table simpleTable = TableTools.newTable(TableTools.col("Sym", "a"), TableTools.intCol("intCol", 30), TableTools.doubleCol("doubleCol", 40.1)).updateView("K=-2L"); final Table source = LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> TableTools.merge(simpleTable, queryTable.updateView("K=k")).flatten()); - final StreamLoggerImpl log = new StreamLoggerImpl(); - final EvalNuggetInterface[] en = new EvalNuggetInterface[]{ - EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(log, source.byExternal("Sym").merge(), 2.0)), "Sym"), - EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(log, source.byExternal("Sym").merge(), 2.0).select()), "Sym"), - EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(log, source.byExternal("Sym").merge(), 4.0)), "Sym"), - EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(log, source.byExternal("Sym").merge(), 4.5)), "Sym"), - EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(log, source.byExternal("Sym").merge(), 4.5).select()), "Sym"), - EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(log, source.byExternal("Sym").merge(), 5.0)), "Sym"), - EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(log, source.byExternal("Sym").merge(), 10.0).select()), "Sym"), - EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(log, source.byExternal("Sym").merge(), 10.0).select()), "Sym"), + EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(source.byExternal("Sym").merge(), 2.0)), "Sym"), + EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(source.byExternal("Sym").merge(), 2.0).select()), "Sym"), + EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(source.byExternal("Sym").merge(), 4.0)), "Sym"), + EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(source.byExternal("Sym").merge(), 4.5)), "Sym"), + EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(source.byExternal("Sym").merge(), 4.5).select()), "Sym"), + EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(source.byExternal("Sym").merge(), 5.0)), "Sym"), + EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(source.byExternal("Sym").merge(), 10.0).select()), "Sym"), + EvalNugget.Sorted.from(() -> LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(source.byExternal("Sym").merge(), 10.0).select()), "Sym"), }; final int steps = 10; @@ -149,7 +147,7 @@ public void testScope() { final SafeCloseable scopeCloseable = LivenessScopeStack.open(); final Table sentinelTable = queryTable.updateView("Sentinel=k"); - final Table densified = LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(new StreamLoggerImpl(), sentinelTable, 3.0)); + final Table densified = LiveTableMonitor.DEFAULT.sharedLock().computeLocked(() -> SelectOverheadLimiter.clampSelectOverhead(sentinelTable, 3.0)); assertEquals(densified.getIndex(), sentinelTable.getIndex()); assertTableEquals(sentinelTable, densified); diff --git a/DB/src/test/java/io/deephaven/db/v2/fuzzertest.groovy b/DB/src/test/java/io/deephaven/db/v2/fuzzertest.groovy index 7e94b017651..faba341a628 100644 --- a/DB/src/test/java/io/deephaven/db/v2/fuzzertest.groovy +++ b/DB/src/test/java/io/deephaven/db/v2/fuzzertest.groovy @@ -1,6 +1,7 @@ import io.deephaven.db.v2.FailureListener import io.deephaven.db.v2.FuzzerPrintListener import io.deephaven.db.v2.TableUpdateValidator +import io.deephaven.db.tables.utils.TableTools tableSeed = 1583360794826387000 as long; size = 100 as int; @@ -8,7 +9,7 @@ scale = 1000 as int; useRandomNullPoints = true as boolean; tableRandom = new Random(tableSeed) as Random; -tt = db.timeTable("00:00:01"); +tt = TableTools.timeTable("00:00:01"); tickingValues = tt.update( "MyString=new String(`a`+i)", "MyInt=new Integer(i)", diff --git a/Plot/src/test/java/io/deephaven/db/plot/example_plots/plotting_samples.groovy b/Plot/src/test/java/io/deephaven/db/plot/example_plots/plotting_samples.groovy index 5bceffd7cb3..2588014d9ba 100644 --- a/Plot/src/test/java/io/deephaven/db/plot/example_plots/plotting_samples.groovy +++ b/Plot/src/test/java/io/deephaven/db/plot/example_plots/plotting_samples.groovy @@ -497,14 +497,14 @@ ColorMapPlot = ColorMapPlot.plot("S1", x, y2).pointColorByY(rangeMap(colorMap)) //////////////////////////////////////////////////////////////////////////////////////////////////// //liveplot1 -t = db.timeTable("00:00:01") +t = TableTools.timeTable("00:00:01") .updateView("I=i","J=sin(I*3.14/25)") LivePlot = plot("S1",t,"I","J").show() //////////////////////////////////////////////////////////////////////////////////////////////////// //liveplot2 -t = db.timeTable("00:00:01") +t = TableTools.timeTable("00:00:01") .updateView("I=i","J=sin(I*3.14/25)","K=sin(I*3.14/25+3.14/4)") LivePlot2 = figure().updateInterval(500) .plot("S1",t,"I","J") @@ -542,6 +542,6 @@ businessPlot = figure(2,1).theme("Dark") //one click -t = db.timeTable("00:00:01") +t = TableTools.timeTable("00:00:01") .updateView("Cat = i%2 == 0 ? `A` : `B`", "I=i", "J = i % 2 == 0 ? sin(I*3.14/10) : cos(I*3.14/10)") LivePlot = plot("S1",oneClick(t, "Cat"),"I","J").show() \ No newline at end of file diff --git a/gradle.properties b/gradle.properties index 27b64255995..f752a435555 100644 --- a/gradle.properties +++ b/gradle.properties @@ -51,7 +51,7 @@ pipCacheDir=build/pipcache # use this to control the jvm arguments of gradle daemons. -org.gradle.jvmargs=-Xms1g -Xmx3g -XX:+CMSClassUnloadingEnabled +org.gradle.jvmargs=-Xms1g -Xmx3g # Setting debugCI to true will cause failed builds to keepalive for three hours so we can do post-mortem inspection of jenkins workspace debugCI=false diff --git a/grpc-api/src/main/java/io/deephaven/grpc_api/table/ExportedTableUpdateListener.java b/grpc-api/src/main/java/io/deephaven/grpc_api/table/ExportedTableUpdateListener.java index 5d279194e32..d24f5121f5c 100644 --- a/grpc-api/src/main/java/io/deephaven/grpc_api/table/ExportedTableUpdateListener.java +++ b/grpc-api/src/main/java/io/deephaven/grpc_api/table/ExportedTableUpdateListener.java @@ -157,7 +157,7 @@ private synchronized void onNewTableExport(final Ticket ticket, final long expor return; } - final ShiftAwareSwapListener swapListener = new ShiftAwareSwapListener(log, table); + final ShiftAwareSwapListener swapListener = new ShiftAwareSwapListener(table); swapListener.subscribeForUpdates(); final ListenerImpl listener = new ListenerImpl(table, exportId, swapListener); manage(listener);