diff --git a/Integrations/python/deephaven/doc/io/deephaven/api/TableOperations.json b/Integrations/python/deephaven/doc/io/deephaven/api/TableOperations.json index 00940353bcb..471a4111d5a 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/api/TableOperations.json +++ b/Integrations/python/deephaven/doc/io/deephaven/api/TableOperations.json @@ -7,7 +7,6 @@ "groupBy": "*Overload 1* \n :return: TableOperations.TOPS\n \n*Overload 2* \n :param groupByColumns: java.lang.String...\n :return: TableOperations.TOPS\n \n*Overload 3* \n :param groupByColumns: java.util.Collection\n :return: TableOperations.TOPS", "head": ":param size: long\n:return: TableOperations.TOPS", "join": "**Incompatible overloads text - text from the first overload:**\n\nPerform a cross join with the rightTable.\n\n \n Delegates to join(Object, Collection, Collection, int).\n\n*Overload 1* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (TableOperations.TOPS) a new table joined according to the specification in columnsToMatch and includes all non-key-columns from\n the right table\n \n*Overload 2* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (TableOperations.TOPS) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 3* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (TableOperations.TOPS) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 4* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :param reserveBits: (int) - The number of bits to reserve for rightTable groups.\n :return: (TableOperations.TOPS) a new table joined according to the specification in columnsToMatch and columnsToAdd", - "leftJoin": "**Incompatible overloads text - text from the first overload:**\n\nPerform a left-join with the rightTable.\n\n \n Delegates to leftJoin(Object, Collection, Collection).\n\n*Overload 1* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (TableOperations.TOPS) the left-joined table\n \n*Overload 2* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (TableOperations.TOPS) the left-joined table\n \n*Overload 3* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (TableOperations.TOPS) a table that has one column for each original table's columns, and one column corresponding to each\n column listed in columnsToAdd. If columnsToAdd.isEmpty() one column corresponding to each column\n of the input table (right table) columns whose names don't overlap with the name of a column from the\n source table is added. The new columns (those corresponding to the input table) contain an aggregation of\n all values from the left side that match the join criteria.", "naturalJoin": "**Incompatible overloads text - text from the first overload:**\n\nPerform a natural-join with the rightTable.\n\n \n Delegates to naturalJoin(Object, Collection, Collection).\n\n*Overload 1* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (TableOperations.TOPS) the natural-joined table\n \n*Overload 2* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (TableOperations.TOPS) the natural-joined table\n \n*Overload 3* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (TableOperations.TOPS) the natural-joined table", "raj": "**Incompatible overloads text - text from the first overload:**\n\nPerform a reverse-as-of join with the rightTable.\n\n \n Delegates to raj(Object, Collection, Collection, ReverseAsOfJoinRule).\n\n*Overload 1* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\").\n :return: (TableOperations.TOPS) a new table joined according to the specification in columnsToMatch\n \n*Overload 2* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\").\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the left side that need to be added to the right\n side as a result of the match.\n :return: (TableOperations.TOPS) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 3* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (TableOperations.TOPS) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 4* \n :param rightTable: (TableOperations.TABLE) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :param reverseAsOfJoinRule: (io.deephaven.api.ReverseAsOfJoinRule) - The binary search operator for the last match pair.\n :return: (TableOperations.TOPS) a new table joined according to the specification in columnsToMatch and columnsToAdd", "reverse": ":return: TableOperations.TOPS", diff --git a/Integrations/python/deephaven/doc/io/deephaven/api/TableOperationsAdapter.json b/Integrations/python/deephaven/doc/io/deephaven/api/TableOperationsAdapter.json index fa83ed2b283..b83b4908561 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/api/TableOperationsAdapter.json +++ b/Integrations/python/deephaven/doc/io/deephaven/api/TableOperationsAdapter.json @@ -8,7 +8,6 @@ "groupBy": "*Overload 1* \n :return: TableOperationsAdapter.TOPS_1\n \n*Overload 2* \n :param groupByColumns: java.lang.String...\n :return: TableOperationsAdapter.TOPS_1\n \n*Overload 3* \n :param groupByColumns: java.util.Collection\n :return: TableOperationsAdapter.TOPS_1", "head": ":param size: long\n:return: TableOperationsAdapter.TOPS_1", "join": "**Incompatible overloads text - text from the first overload:**\n\nPerform a cross join with the rightTable.\n\n \n Delegates to TableOperations.join(Object, Collection, Collection, int).\n\n*Overload 1* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (TableOperationsAdapter.TOPS_1) a new table joined according to the specification in columnsToMatch and includes all non-key-columns from\n the right table\n \n*Overload 2* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (TableOperationsAdapter.TOPS_1) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 3* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (TableOperationsAdapter.TOPS_1) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 4* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :param reserveBits: (int) - The number of bits to reserve for rightTable groups.\n :return: (TableOperationsAdapter.TOPS_1) a new table joined according to the specification in columnsToMatch and columnsToAdd", - "leftJoin": "**Incompatible overloads text - text from the first overload:**\n\nPerform a left-join with the rightTable.\n\n \n Delegates to TableOperations.leftJoin(Object, Collection, Collection).\n\n*Overload 1* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (TableOperationsAdapter.TOPS_1) the left-joined table\n \n*Overload 2* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (TableOperationsAdapter.TOPS_1) the left-joined table\n \n*Overload 3* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (TableOperationsAdapter.TOPS_1) a table that has one column for each original table's columns, and one column corresponding to each\n column listed in columnsToAdd. If columnsToAdd.isEmpty() one column corresponding to each column\n of the input table (right table) columns whose names don't overlap with the name of a column from the\n source table is added. The new columns (those corresponding to the input table) contain an aggregation of\n all values from the left side that match the join criteria.", "naturalJoin": "**Incompatible overloads text - text from the first overload:**\n\nPerform a natural-join with the rightTable.\n\n \n Delegates to TableOperations.naturalJoin(Object, Collection, Collection).\n\n*Overload 1* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (TableOperationsAdapter.TOPS_1) the natural-joined table\n \n*Overload 2* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (TableOperationsAdapter.TOPS_1) the natural-joined table\n \n*Overload 3* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (TableOperationsAdapter.TOPS_1) the natural-joined table", "raj": "**Incompatible overloads text - text from the first overload:**\n\nPerform a reverse-as-of join with the rightTable.\n\n \n Delegates to TableOperations.raj(Object, Collection, Collection, ReverseAsOfJoinRule).\n\n*Overload 1* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\").\n :return: (TableOperationsAdapter.TOPS_1) a new table joined according to the specification in columnsToMatch\n \n*Overload 2* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\").\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the left side that need to be added to the right\n side as a result of the match.\n :return: (TableOperationsAdapter.TOPS_1) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 3* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (TableOperationsAdapter.TOPS_1) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 4* \n :param rightTable: (TableOperationsAdapter.TABLE_1) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :param reverseAsOfJoinRule: (io.deephaven.api.ReverseAsOfJoinRule) - The binary search operator for the last match pair.\n :return: (TableOperationsAdapter.TOPS_1) a new table joined according to the specification in columnsToMatch and columnsToAdd", "reverse": ":return: TableOperationsAdapter.TOPS_1", diff --git a/Integrations/python/deephaven/doc/io/deephaven/chunk/Attributes.json b/Integrations/python/deephaven/doc/io/deephaven/chunk/Attributes.json deleted file mode 100644 index c34d6960866..00000000000 --- a/Integrations/python/deephaven/doc/io/deephaven/chunk/Attributes.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "className": "io.deephaven.chunk.Attributes", - "methods": {}, - "path": "io.deephaven.chunk.Attributes", - "text": "Attributes that may apply to a Chunk.", - "typeName": "class" -} \ No newline at end of file diff --git a/Integrations/python/deephaven/doc/io/deephaven/engine/table/Table.json b/Integrations/python/deephaven/doc/io/deephaven/engine/table/Table.json index bbfd8d047c9..fe7562f028d 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/engine/table/Table.json +++ b/Integrations/python/deephaven/doc/io/deephaven/engine/table/Table.json @@ -55,7 +55,6 @@ "join": "**Incompatible overloads text - text from the first overload:**\n\nPerform a cross join with the right table.\n \n Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left\n table's columns, and one column corresponding to each of the right table's columns that are included in the\n columnsToAdd argument. The rows are ordered first by the left table then by the right table. If columnsToMatch is\n non-empty then the product is filtered by the supplied match conditions.\n \n To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless\n specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the\n right rows for a given aggregation group the table will shift a bit from the left side to the right side. The\n default of 16 bits was carefully chosen because it results in an efficient implementation to process live\n updates.\n \n An OutOfKeySpaceException is thrown when the total number of bits needed\n to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If\n the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table\n is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can\n reserve fewer bits by setting numRightBitsToReserve on initialization.\n \n Note: If you can prove that a given group has at most one right-row then you should prefer using\n naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[]).\n\n*Overload 1* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification with zero key-columns and includes all right columns\n \n*Overload 2* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification with zero key-columns and includes all right columns\n \n*Overload 3* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and includes all non-key-columns from\n the right table\n \n*Overload 4* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and includes all non-key-columns from\n the right table\n \n*Overload 5* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 6* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 7* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - An array of match pair conditions (\"leftColumn=rightColumn\" or \"columnFoundInBoth\")\n :param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - An array of the columns from the right side that need to be added to the left side as a\n result of the match.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 8* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - An array of match pair conditions (\"leftColumn=rightColumn\" or \"columnFoundInBoth\")\n :param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - An array of the columns from the right side that need to be added to the left side as a\n result of the match.\n :param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 9* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 10* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd", "lastBy": "**Incompatible overloads text - text from the first overload:**\n\nGroups the data column according to groupByColumns and retrieves the last for the rest of the fields\n\n*Overload 1* \n :param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in groupBy(java.util.Collection)\n :return: io.deephaven.engine.table.Table\n \n*Overload 2* \n :param groupByColumns: (java.lang.String...) - The grouping columns as in groupBy(java.util.Collection)\n :return: io.deephaven.engine.table.Table\n \n*Overload 3* \n :param groupByColumns: (java.util.Collection) - The grouping columns as in groupBy(java.util.Collection)\n :return: io.deephaven.engine.table.Table\n \n*Overload 4* \n :return: io.deephaven.engine.table.Table", "lazyUpdate": "Compute column formulas on demand.\n\n \n Lazy update defers computation until required for a set of values, and caches the results for a set of input\n values. This uses less RAM than an update statement when you have a smaller set of unique values. Less\n computation than an updateView is needed, because the results are saved in a cache.\n \n\n If you have many unique values, you should instead use an update statement, which will have more memory efficient\n structures. Values are never removed from the lazyUpdate cache, so it should be used judiciously on a ticking\n table.\n\n*Overload 1* \n :param newColumns: (java.util.Collection) - the columns to add\n :return: (io.deephaven.engine.table.Table) a new Table with the columns added; to be computed on demand\n \n*Overload 2* \n :param newColumns: io.deephaven.api.Selectable...\n :return: io.deephaven.engine.table.Table\n \n*Overload 3* \n :param newColumns: java.lang.String...\n :return: io.deephaven.engine.table.Table", - "leftJoin": "**Incompatible overloads text - text from the first overload:**\n\nPerform a left-join with the rightTable.\n\n \n Delegates to TableOperations.leftJoin(Object, Collection, Collection).\n\n*Overload 1* \n :param rightTable: (io.deephaven.engine.table.Table) - input table\n :param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - match criteria\n :param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - columns to add\n :return: (io.deephaven.engine.table.Table) a table that has one column for each original table's columns, and one column corresponding to each\n column listed in columnsToAdd. If columnsToAdd.length==0 one column corresponding to each column of the\n input table (right table) columns whose names don't overlap with the name of a column from the source\n table is added. The new columns (those corresponding to the input table) contain an aggregation of all\n values from the left side that match the join criteria.\n \n*Overload 2* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (io.deephaven.engine.table.Table) a table that has one column for each original table's columns, and one column corresponding to each\n column listed in columnsToAdd. If columnsToAdd.isEmpty() one column corresponding to each column\n of the input table (right table) columns whose names don't overlap with the name of a column from the\n source table is added. The new columns (those corresponding to the input table) contain an aggregation of\n all values from the left side that match the join criteria.\n \n*Overload 3* \n :param rightTable: io.deephaven.engine.table.Table\n :param columnsToMatch: java.util.Collection\n :return: io.deephaven.engine.table.Table\n \n*Overload 4* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (io.deephaven.engine.table.Table) the left-joined table\n \n*Overload 5* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (io.deephaven.engine.table.Table) the left-joined table\n \n*Overload 6* \n :param rightTable: io.deephaven.engine.table.Table\n :return: io.deephaven.engine.table.Table", "listenForUpdates": "**Incompatible overloads text - text from the first overload:**\n\nSubscribe for updates to this table. After the optional initial image, listener will be invoked via the\n NotificationQueue associated with this Table.\n\n*Overload 1* \n :param listener: (io.deephaven.engine.table.ShiftObliviousListener) - listener for updates\n \n*Overload 2* \n :param listener: (io.deephaven.engine.table.ShiftObliviousListener) - listener for updates\n :param replayInitialImage: (boolean) - true to process updates for all initial rows in the table plus all changes; false to\n only process changes\n \n*Overload 3* \n :param listener: (io.deephaven.engine.table.TableUpdateListener) - listener for updates", "longColumnIterator": ":param columnName: java.lang.String\n:return: io.deephaven.engine.table.iterators.LongColumnIterator", "maxBy": "**Incompatible overloads text - text from the first overload:**\n\nGroups the data column according to groupByColumns and computes the max for the rest of the fields\n\n*Overload 1* \n :param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in groupBy(java.util.Collection) }\n :return: io.deephaven.engine.table.Table\n \n*Overload 2* \n :param groupByColumns: (java.lang.String...) - The grouping columns as in groupBy(java.util.Collection) }\n :return: io.deephaven.engine.table.Table\n \n*Overload 3* \n :param groupByColumns: (java.util.Collection) - The grouping columns as in groupBy(java.util.Collection) }\n :return: io.deephaven.engine.table.Table\n \n*Overload 4* \n :return: io.deephaven.engine.table.Table", diff --git a/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/HierarchicalTable.json b/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/HierarchicalTable.json index 2496882df3a..e114b096a0f 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/HierarchicalTable.json +++ b/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/HierarchicalTable.json @@ -24,7 +24,6 @@ "join": "Perform a cross join with the right table.\n \n Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left\n table's columns, and one column corresponding to each of the right table's columns that are included in the\n columnsToAdd argument. The rows are ordered first by the left table then by the right table. If columnsToMatch is\n non-empty then the product is filtered by the supplied match conditions.\n \n To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless\n specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the\n right rows for a given aggregation group the table will shift a bit from the left side to the right side. The\n default of 16 bits was carefully chosen because it results in an efficient implementation to process live\n updates.\n \n An OutOfKeySpaceException is thrown when the total number of bits needed\n to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If\n the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table\n is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can\n reserve fewer bits by setting numRightBitsToReserve on initialization.\n \n Note: If you can prove that a given group has at most one right-row then you should prefer using\n Table.naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[]).\n\n:param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n:param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - An array of match pair conditions (\"leftColumn=rightColumn\" or \"columnFoundInBoth\")\n:param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - An array of the columns from the right side that need to be added to the left side as a\n result of the match.\n:param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n:return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd", "lastBy": "Groups the data column according to groupByColumns and retrieves the last for the rest of the fields\n\n:param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in Table.groupBy(java.util.Collection)\n:return: io.deephaven.engine.table.Table", "lazyUpdate": "Compute column formulas on demand.\n\n \n Lazy update defers computation until required for a set of values, and caches the results for a set of input\n values. This uses less RAM than an update statement when you have a smaller set of unique values. Less\n computation than an updateView is needed, because the results are saved in a cache.\n \n\n If you have many unique values, you should instead use an update statement, which will have more memory efficient\n structures. Values are never removed from the lazyUpdate cache, so it should be used judiciously on a ticking\n table.\n \n\n:param columns: (java.util.Collection) - the columns to add\n:return: (io.deephaven.engine.table.Table) a new Table with the columns added; to be computed on demand", - "leftJoin": "Returns a table that has one column for each original table's columns, and one column corresponding to each of\n the input table (right table) columns listed in the columns to add (or all the columns whose names don't overlap\n with the name of a column from the source table if the columnsToAdd is length zero). The new columns (those\n corresponding to the input table) contain an aggregation of all values from the left side that match the join\n criteria. Consequently, the types of all right side columns not involved in a join criteria, is an array of the\n original column type. If the two tables have columns with matching names then the method will fail with an\n exception unless the columns with corresponding names are found in one of the matching criteria.\n \n\n NOTE: leftJoin operation does not involve an actual data copy, or an in-memory table creation. In order to\n produce an actual in memory table you need to apply a select call on the join result.\n\n:param table: (io.deephaven.engine.table.Table) - input table\n:param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - match criteria\n:param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - columns to add\n:return: (io.deephaven.engine.table.Table) a table that has one column for each original table's columns, and one column corresponding to each\n column listed in columnsToAdd. If columnsToAdd.length==0 one column corresponding to each column of the\n input table (right table) columns whose names don't overlap with the name of a column from the source\n table is added. The new columns (those corresponding to the input table) contain an aggregation of all\n values from the left side that match the join criteria.", "maxBy": "Groups the data column according to groupByColumns and computes the max for the rest of the fields\n\n:param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in Table.groupBy(java.util.Collection) }\n:return: io.deephaven.engine.table.Table", "medianBy": "Groups the data column according to groupByColumns and computes the median for the rest of the\n fields\n\n:param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in Table.groupBy(java.util.Collection) }\n:return: io.deephaven.engine.table.Table", "minBy": "Groups the data column according to groupByColumns and computes the min for the rest of the fields\n\n:param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in Table.groupBy(java.util.Collection)\n:return: io.deephaven.engine.table.Table", diff --git a/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/QueryTable.json b/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/QueryTable.json index 7292d3e9111..26df36debc1 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/QueryTable.json +++ b/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/QueryTable.json @@ -33,7 +33,6 @@ "join": "Perform a cross join with the right table.\n \n Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left\n table's columns, and one column corresponding to each of the right table's columns that are included in the\n columnsToAdd argument. The rows are ordered first by the left table then by the right table. If columnsToMatch is\n non-empty then the product is filtered by the supplied match conditions.\n \n To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless\n specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the\n right rows for a given aggregation group the table will shift a bit from the left side to the right side. The\n default of 16 bits was carefully chosen because it results in an efficient implementation to process live\n updates.\n \n An OutOfKeySpaceException is thrown when the total number of bits needed\n to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If\n the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table\n is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can\n reserve fewer bits by setting numRightBitsToReserve on initialization.\n \n Note: If you can prove that a given group has at most one right-row then you should prefer using\n Table.naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[]).\n\n:param rightTableCandidate: (io.deephaven.engine.table.Table) - The right side table on the join.\n:param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - An array of match pair conditions (\"leftColumn=rightColumn\" or \"columnFoundInBoth\")\n:param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - An array of the columns from the right side that need to be added to the left side as a\n result of the match.\n:param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n:return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd", "lastBy": "Groups the data column according to groupByColumns and retrieves the last for the rest of the fields\n\n:param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in Table.groupBy(java.util.Collection)\n:return: io.deephaven.engine.table.Table", "lazyUpdate": "Compute column formulas on demand.\n\n \n Lazy update defers computation until required for a set of values, and caches the results for a set of input\n values. This uses less RAM than an update statement when you have a smaller set of unique values. Less\n computation than an updateView is needed, because the results are saved in a cache.\n \n\n If you have many unique values, you should instead use an update statement, which will have more memory efficient\n structures. Values are never removed from the lazyUpdate cache, so it should be used judiciously on a ticking\n table.\n \n\n:param newColumns: (java.util.Collection) - the columns to add\n:return: (io.deephaven.engine.table.Table) a new Table with the columns added; to be computed on demand", - "leftJoin": "Returns a table that has one column for each original table's columns, and one column corresponding to each of\n the input table (right table) columns listed in the columns to add (or all the columns whose names don't overlap\n with the name of a column from the source table if the columnsToAdd is length zero). The new columns (those\n corresponding to the input table) contain an aggregation of all values from the left side that match the join\n criteria. Consequently, the types of all right side columns not involved in a join criteria, is an array of the\n original column type. If the two tables have columns with matching names then the method will fail with an\n exception unless the columns with corresponding names are found in one of the matching criteria.\n \n\n NOTE: leftJoin operation does not involve an actual data copy, or an in-memory table creation. In order to\n produce an actual in memory table you need to apply a select call on the join result.\n\n:param table: (io.deephaven.engine.table.Table) - input table\n:param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - match criteria\n:param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - columns to add\n:return: (io.deephaven.engine.table.Table) a table that has one column for each original table's columns, and one column corresponding to each\n column listed in columnsToAdd. If columnsToAdd.length==0 one column corresponding to each column of the\n input table (right table) columns whose names don't overlap with the name of a column from the source\n table is added. The new columns (those corresponding to the input table) contain an aggregation of all\n values from the left side that match the join criteria.", "maxBy": "Groups the data column according to groupByColumns and computes the max for the rest of the fields\n\n:param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in Table.groupBy(java.util.Collection) }\n:return: io.deephaven.engine.table.Table", "medianBy": "Groups the data column according to groupByColumns and computes the median for the rest of the\n fields\n\n:param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in Table.groupBy(java.util.Collection) }\n:return: io.deephaven.engine.table.Table", "memoizeResult": "Saves a weak reference to the result of the given operation.\n\nNote: Java generics information - \n\n:param memoKey: (io.deephaven.engine.table.impl.MemoizedOperationKey) - a complete description of the operation, if null no memoization is performed\n:param operation: (java.util.function.Supplier) - a supplier for the result\n:return: (R) either the cached or newly generated result", diff --git a/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/TableWithDefaults.json b/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/TableWithDefaults.json index de52e2169ce..fe2bf3bc686 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/TableWithDefaults.json +++ b/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/TableWithDefaults.json @@ -36,7 +36,6 @@ "join": "**Incompatible overloads text - text from the first overload:**\n\nPerform a cross join with the right table.\n \n Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left\n table's columns, and one column corresponding to each of the right table's columns that are included in the\n columnsToAdd argument. The rows are ordered first by the left table then by the right table. If columnsToMatch is\n non-empty then the product is filtered by the supplied match conditions.\n \n To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless\n specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the\n right rows for a given aggregation group the table will shift a bit from the left side to the right side. The\n default of 16 bits was carefully chosen because it results in an efficient implementation to process live\n updates.\n \n An OutOfKeySpaceException is thrown when the total number of bits needed\n to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If\n the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table\n is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can\n reserve fewer bits by setting numRightBitsToReserve on initialization.\n \n Note: If you can prove that a given group has at most one right-row then you should prefer using\n Table.naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[]).\n\n*Overload 1* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification with zero key-columns and includes all right columns\n \n*Overload 2* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification with zero key-columns and includes all right columns\n \n*Overload 3* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and includes all non-key-columns from\n the right table\n \n*Overload 4* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and includes all non-key-columns from\n the right table\n \n*Overload 5* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 6* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 7* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - An array of match pair conditions (\"leftColumn=rightColumn\" or \"columnFoundInBoth\")\n :param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - An array of the columns from the right side that need to be added to the left side as a\n result of the match.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 8* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 9* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd", "lastBy": "**Incompatible overloads text - text from the first overload:**\n\nGroups the data column according to groupByColumns and retrieves the last for the rest of the fields\n\n*Overload 1* \n :param groupByColumns: (java.lang.String...) - The grouping columns as in Table.groupBy(java.util.Collection)\n :return: io.deephaven.engine.table.Table\n \n*Overload 2* \n :param groupByColumns: (java.util.Collection) - The grouping columns as in Table.groupBy(java.util.Collection)\n :return: io.deephaven.engine.table.Table\n \n*Overload 3* \n :return: io.deephaven.engine.table.Table", "lazyUpdate": "*Overload 1* \n :param newColumns: io.deephaven.api.Selectable...\n :return: io.deephaven.engine.table.Table\n \n*Overload 2* \n :param newColumns: java.lang.String...\n :return: io.deephaven.engine.table.Table", - "leftJoin": "**Incompatible overloads text - text from the first overload:**\n\nPerform a left-join with the rightTable.\n\n \n Delegates to TableOperations.leftJoin(Object, Collection, Collection).\n\n*Overload 1* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (io.deephaven.engine.table.Table) a table that has one column for each original table's columns, and one column corresponding to each\n column listed in columnsToAdd. If columnsToAdd.isEmpty() one column corresponding to each column\n of the input table (right table) columns whose names don't overlap with the name of a column from the\n source table is added. The new columns (those corresponding to the input table) contain an aggregation of\n all values from the left side that match the join criteria.\n \n*Overload 2* \n :param rightTable: io.deephaven.engine.table.Table\n :param columnsToMatch: java.util.Collection\n :return: io.deephaven.engine.table.Table\n \n*Overload 3* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (io.deephaven.engine.table.Table) the left-joined table\n \n*Overload 4* \n :param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (io.deephaven.engine.table.Table) the left-joined table\n \n*Overload 5* \n :param rightTable: io.deephaven.engine.table.Table\n :return: io.deephaven.engine.table.Table", "listenForUpdates": "Subscribe for updates to this table. listener will be invoked via the NotificationQueue\n associated with this Table.\n\n:param listener: (io.deephaven.engine.table.ShiftObliviousListener) - listener for updates", "longColumnIterator": ":param columnName: java.lang.String\n:return: io.deephaven.engine.table.iterators.LongColumnIterator", "maxBy": "**Incompatible overloads text - text from the first overload:**\n\nGroups the data column according to groupByColumns and computes the max for the rest of the fields\n\n*Overload 1* \n :param groupByColumns: (java.lang.String...) - The grouping columns as in Table.groupBy(java.util.Collection) }\n :return: io.deephaven.engine.table.Table\n \n*Overload 2* \n :param groupByColumns: (java.util.Collection) - The grouping columns as in Table.groupBy(java.util.Collection) }\n :return: io.deephaven.engine.table.Table\n \n*Overload 3* \n :return: io.deephaven.engine.table.Table", diff --git a/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/UncoalescedTable.json b/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/UncoalescedTable.json index edf9bf5568b..7fde6add7d4 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/UncoalescedTable.json +++ b/Integrations/python/deephaven/doc/io/deephaven/engine/table/impl/UncoalescedTable.json @@ -38,7 +38,6 @@ "join": "Perform a cross join with the right table.\n \n Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left\n table's columns, and one column corresponding to each of the right table's columns that are included in the\n columnsToAdd argument. The rows are ordered first by the left table then by the right table. If columnsToMatch is\n non-empty then the product is filtered by the supplied match conditions.\n \n To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless\n specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the\n right rows for a given aggregation group the table will shift a bit from the left side to the right side. The\n default of 16 bits was carefully chosen because it results in an efficient implementation to process live\n updates.\n \n An OutOfKeySpaceException is thrown when the total number of bits needed\n to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If\n the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table\n is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can\n reserve fewer bits by setting numRightBitsToReserve on initialization.\n \n Note: If you can prove that a given group has at most one right-row then you should prefer using\n Table.naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[]).\n\n:param rightTable: (io.deephaven.engine.table.Table) - The right side table on the join.\n:param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - An array of match pair conditions (\"leftColumn=rightColumn\" or \"columnFoundInBoth\")\n:param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - An array of the columns from the right side that need to be added to the left side as a\n result of the match.\n:param numRightBitsToReserve: (int) - The number of bits to reserve for rightTable groups.\n:return: (io.deephaven.engine.table.Table) a new table joined according to the specification in columnsToMatch and columnsToAdd", "lastBy": "Groups the data column according to groupByColumns and retrieves the last for the rest of the fields\n\n:param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in Table.groupBy(java.util.Collection)\n:return: io.deephaven.engine.table.Table", "lazyUpdate": "Compute column formulas on demand.\n\n \n Lazy update defers computation until required for a set of values, and caches the results for a set of input\n values. This uses less RAM than an update statement when you have a smaller set of unique values. Less\n computation than an updateView is needed, because the results are saved in a cache.\n \n\n If you have many unique values, you should instead use an update statement, which will have more memory efficient\n structures. Values are never removed from the lazyUpdate cache, so it should be used judiciously on a ticking\n table.\n \n\n:param newColumns: (java.util.Collection) - the columns to add\n:return: (io.deephaven.engine.table.Table) a new Table with the columns added; to be computed on demand", - "leftJoin": "Returns a table that has one column for each original table's columns, and one column corresponding to each of\n the input table (right table) columns listed in the columns to add (or all the columns whose names don't overlap\n with the name of a column from the source table if the columnsToAdd is length zero). The new columns (those\n corresponding to the input table) contain an aggregation of all values from the left side that match the join\n criteria. Consequently, the types of all right side columns not involved in a join criteria, is an array of the\n original column type. If the two tables have columns with matching names then the method will fail with an\n exception unless the columns with corresponding names are found in one of the matching criteria.\n \n\n NOTE: leftJoin operation does not involve an actual data copy, or an in-memory table creation. In order to\n produce an actual in memory table you need to apply a select call on the join result.\n\n:param rightTable: (io.deephaven.engine.table.Table) - input table\n:param columnsToMatch: (io.deephaven.engine.table.MatchPair[]) - match criteria\n:param columnsToAdd: (io.deephaven.engine.table.MatchPair[]) - columns to add\n:return: (io.deephaven.engine.table.Table) a table that has one column for each original table's columns, and one column corresponding to each\n column listed in columnsToAdd. If columnsToAdd.length==0 one column corresponding to each column of the\n input table (right table) columns whose names don't overlap with the name of a column from the source\n table is added. The new columns (those corresponding to the input table) contain an aggregation of all\n values from the left side that match the join criteria.", "listenForUpdates": "**Incompatible overloads text - text from the first overload:**\n\nSubscribe for updates to this table. After the optional initial image, listener will be invoked via the\n NotificationQueue associated with this Table.\n\n*Overload 1* \n :param listener: (io.deephaven.engine.table.ShiftObliviousListener) - listener for updates\n :param replayInitialImage: (boolean) - true to process updates for all initial rows in the table plus all changes; false to\n only process changes\n \n*Overload 2* \n :param listener: (io.deephaven.engine.table.TableUpdateListener) - listener for updates", "longColumnIterator": ":param columnName: java.lang.String\n:return: io.deephaven.engine.table.iterators.LongColumnIterator", "maxBy": "Groups the data column according to groupByColumns and computes the max for the rest of the fields\n\n:param groupByColumns: (io.deephaven.api.Selectable...) - The grouping columns as in Table.groupBy(java.util.Collection) }\n:return: io.deephaven.engine.table.Table", diff --git a/Integrations/python/deephaven/doc/io/deephaven/qst/table/LeftJoinTable.json b/Integrations/python/deephaven/doc/io/deephaven/qst/table/LeftJoinTable.json deleted file mode 100644 index 7b5b2b98428..00000000000 --- a/Integrations/python/deephaven/doc/io/deephaven/qst/table/LeftJoinTable.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "className": "io.deephaven.qst.table.LeftJoinTable", - "methods": { - "builder": ":return: io.deephaven.qst.table.LeftJoinTable.Builder", - "walk": "Note: Java generics information - \n\n:param visitor: V\n:return: V" - }, - "path": "io.deephaven.qst.table.LeftJoinTable", - "typeName": "class" -} \ No newline at end of file diff --git a/Integrations/python/deephaven/doc/io/deephaven/qst/table/LeftJoinTable/Builder.json b/Integrations/python/deephaven/doc/io/deephaven/qst/table/LeftJoinTable/Builder.json deleted file mode 100644 index 6154e0d46bf..00000000000 --- a/Integrations/python/deephaven/doc/io/deephaven/qst/table/LeftJoinTable/Builder.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "className": "io.deephaven.qst.table.LeftJoinTable$Builder", - "methods": {}, - "path": "io.deephaven.qst.table.LeftJoinTable.Builder", - "typeName": "interface" -} \ No newline at end of file diff --git a/Integrations/python/deephaven/doc/io/deephaven/qst/table/LinkDescriber.json b/Integrations/python/deephaven/doc/io/deephaven/qst/table/LinkDescriber.json index c5c7e3f7d1d..7db8927a622 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/qst/table/LinkDescriber.json +++ b/Integrations/python/deephaven/doc/io/deephaven/qst/table/LinkDescriber.json @@ -3,7 +3,7 @@ "methods": { "accept": ":param t: io.deephaven.qst.table.TableSpec", "join": ":param join: io.deephaven.qst.table.Join", - "visit": "*Overload 1* \n :param naturalJoinTable: io.deephaven.qst.table.NaturalJoinTable\n \n*Overload 2* \n :param exactJoinTable: io.deephaven.qst.table.ExactJoinTable\n \n*Overload 3* \n :param joinTable: io.deephaven.qst.table.JoinTable\n \n*Overload 4* \n :param leftJoinTable: io.deephaven.qst.table.LeftJoinTable\n \n*Overload 5* \n :param aj: io.deephaven.qst.table.AsOfJoinTable\n \n*Overload 6* \n :param raj: io.deephaven.qst.table.ReverseAsOfJoinTable\n \n*Overload 7* \n :param whereInTable: io.deephaven.qst.table.WhereInTable\n \n*Overload 8* \n :param whereNotInTable: io.deephaven.qst.table.WhereNotInTable\n \n*Overload 9* \n :param snapshotTable: io.deephaven.qst.table.SnapshotTable\n \n*Overload 10* \n :param inputTable: io.deephaven.qst.table.InputTable" + "visit": "*Overload 1* \n :param naturalJoinTable: io.deephaven.qst.table.NaturalJoinTable\n \n*Overload 2* \n :param exactJoinTable: io.deephaven.qst.table.ExactJoinTable\n \n*Overload 3* \n :param joinTable: io.deephaven.qst.table.JoinTable\n \n*Overload 4* \n :param aj: io.deephaven.qst.table.AsOfJoinTable\n \n*Overload 5* \n :param raj: io.deephaven.qst.table.ReverseAsOfJoinTable\n \n*Overload 6* \n :param whereInTable: io.deephaven.qst.table.WhereInTable\n \n*Overload 7* \n :param whereNotInTable: io.deephaven.qst.table.WhereNotInTable\n \n*Overload 8* \n :param snapshotTable: io.deephaven.qst.table.SnapshotTable\n \n*Overload 9* \n :param inputTable: io.deephaven.qst.table.InputTable" }, "path": "io.deephaven.qst.table.LinkDescriber", "text": "Provides a potentially descriptive label for the parents of a TableSpec.", diff --git a/Integrations/python/deephaven/doc/io/deephaven/qst/table/ParentsVisitor.json b/Integrations/python/deephaven/doc/io/deephaven/qst/table/ParentsVisitor.json index f31aa54ec25..ebd8ca937a7 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/qst/table/ParentsVisitor.json +++ b/Integrations/python/deephaven/doc/io/deephaven/qst/table/ParentsVisitor.json @@ -8,7 +8,7 @@ "postOrderWalk": "**Incompatible overloads text - text from the first overload:**\n\nInvoke the consumer for each table in the de-duplicated, post-order walk from tables.\n\n \n Post-order means that for any given table, the table's dependencies will come before the table itself. There may\n be multiple valid post-orderings; callers should not rely on a specific post-ordering.\n\n*Overload 1* \n :param tables: (java.lang.Iterable) - the tables\n :param consumer: (java.util.function.Consumer) - the consumer\n \n*Overload 2* \n :param tables: (java.lang.Iterable) - the tables\n :param visitor: (io.deephaven.qst.table.TableSpec.Visitor) - the visitor", "reachable": "Create a reachable set from tables, including tables. May be in any order.\n\n:param tables: (java.lang.Iterable) - the tables\n:return: (java.util.Set) the reachable set", "search": "Performs a search for a table that satisfies searchPredicate. Will follow the dependencies of\n initialInputs. Tables that match excludePaths will not be returned, and will not have its\n dependencies added to the search.\n\n \n Note: a dependency of a table that matches excludePaths will be returned if there is any path to that\n dependency that doesn't go through excludePaths.\n\n:param initialInputs: java.lang.Iterable\n:param excludePaths: java.util.function.Predicate\n:param searchPredicate: java.util.function.Predicate\n:return: java.util.Optional", - "visit": "*Overload 1* \n :param emptyTable: io.deephaven.qst.table.EmptyTable\n \n*Overload 2* \n :param newTable: io.deephaven.qst.table.NewTable\n \n*Overload 3* \n :param timeTable: io.deephaven.qst.table.TimeTable\n \n*Overload 4* \n :param mergeTable: io.deephaven.qst.table.MergeTable\n \n*Overload 5* \n :param headTable: io.deephaven.qst.table.HeadTable\n \n*Overload 6* \n :param tailTable: io.deephaven.qst.table.TailTable\n \n*Overload 7* \n :param reverseTable: io.deephaven.qst.table.ReverseTable\n \n*Overload 8* \n :param sortTable: io.deephaven.qst.table.SortTable\n \n*Overload 9* \n :param snapshotTable: io.deephaven.qst.table.SnapshotTable\n \n*Overload 10* \n :param whereTable: io.deephaven.qst.table.WhereTable\n \n*Overload 11* \n :param whereInTable: io.deephaven.qst.table.WhereInTable\n \n*Overload 12* \n :param whereNotInTable: io.deephaven.qst.table.WhereNotInTable\n \n*Overload 13* \n :param naturalJoinTable: io.deephaven.qst.table.NaturalJoinTable\n \n*Overload 14* \n :param exactJoinTable: io.deephaven.qst.table.ExactJoinTable\n \n*Overload 15* \n :param joinTable: io.deephaven.qst.table.JoinTable\n \n*Overload 16* \n :param leftJoinTable: io.deephaven.qst.table.LeftJoinTable\n \n*Overload 17* \n :param aj: io.deephaven.qst.table.AsOfJoinTable\n \n*Overload 18* \n :param raj: io.deephaven.qst.table.ReverseAsOfJoinTable\n \n*Overload 19* \n :param viewTable: io.deephaven.qst.table.ViewTable\n \n*Overload 20* \n :param selectTable: io.deephaven.qst.table.SelectTable\n \n*Overload 21* \n :param updateViewTable: io.deephaven.qst.table.UpdateViewTable\n \n*Overload 22* \n :param updateTable: io.deephaven.qst.table.UpdateTable\n \n*Overload 23* \n :param groupByTable: io.deephaven.qst.table.GroupByTable\n \n*Overload 24* \n :param aggregationTable: io.deephaven.qst.table.AggregationTable\n \n*Overload 25* \n :param ticketTable: io.deephaven.qst.table.TicketTable\n \n*Overload 26* \n :param inputTable: io.deephaven.qst.table.InputTable" + "visit": "*Overload 1* \n :param emptyTable: io.deephaven.qst.table.EmptyTable\n \n*Overload 2* \n :param newTable: io.deephaven.qst.table.NewTable\n \n*Overload 3* \n :param timeTable: io.deephaven.qst.table.TimeTable\n \n*Overload 4* \n :param mergeTable: io.deephaven.qst.table.MergeTable\n \n*Overload 5* \n :param headTable: io.deephaven.qst.table.HeadTable\n \n*Overload 6* \n :param tailTable: io.deephaven.qst.table.TailTable\n \n*Overload 7* \n :param reverseTable: io.deephaven.qst.table.ReverseTable\n \n*Overload 8* \n :param sortTable: io.deephaven.qst.table.SortTable\n \n*Overload 9* \n :param snapshotTable: io.deephaven.qst.table.SnapshotTable\n \n*Overload 10* \n :param whereTable: io.deephaven.qst.table.WhereTable\n \n*Overload 11* \n :param whereInTable: io.deephaven.qst.table.WhereInTable\n \n*Overload 12* \n :param whereNotInTable: io.deephaven.qst.table.WhereNotInTable\n \n*Overload 13* \n :param naturalJoinTable: io.deephaven.qst.table.NaturalJoinTable\n \n*Overload 14* \n :param exactJoinTable: io.deephaven.qst.table.ExactJoinTable\n \n*Overload 15* \n :param joinTable: io.deephaven.qst.table.JoinTable\n \n*Overload 16* \n :param aj: io.deephaven.qst.table.AsOfJoinTable\n \n*Overload 17* \n :param raj: io.deephaven.qst.table.ReverseAsOfJoinTable\n \n*Overload 18* \n :param viewTable: io.deephaven.qst.table.ViewTable\n \n*Overload 19* \n :param selectTable: io.deephaven.qst.table.SelectTable\n \n*Overload 20* \n :param updateViewTable: io.deephaven.qst.table.UpdateViewTable\n \n*Overload 21* \n :param updateTable: io.deephaven.qst.table.UpdateTable\n \n*Overload 22* \n :param groupByTable: io.deephaven.qst.table.GroupByTable\n \n*Overload 23* \n :param aggregationTable: io.deephaven.qst.table.AggregationTable\n \n*Overload 24* \n :param ticketTable: io.deephaven.qst.table.TicketTable\n \n*Overload 25* \n :param inputTable: io.deephaven.qst.table.InputTable" }, "path": "io.deephaven.qst.table.ParentsVisitor", "text": "A visitor that returns the parent tables (if any) of the given table.", diff --git a/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableBase.json b/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableBase.json index e02b5cb803a..b2af6d7a6e8 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableBase.json +++ b/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableBase.json @@ -7,7 +7,6 @@ "groupBy": "*Overload 1* \n :return: io.deephaven.qst.table.GroupByTable\n \n*Overload 2* \n :param groupByColumns: java.lang.String...\n :return: io.deephaven.qst.table.GroupByTable\n \n*Overload 3* \n :param groupByColumns: java.util.Collection\n :return: io.deephaven.qst.table.GroupByTable", "head": ":param size: long\n:return: io.deephaven.qst.table.HeadTable", "join": "**Incompatible overloads text - text from the first overload:**\n\nPerform a cross join with the rightTable.\n\n \n Delegates to TableOperations.join(Object, Collection, Collection, int).\n\n*Overload 1* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (io.deephaven.qst.table.JoinTable) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 2* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :param reserveBits: (int) - The number of bits to reserve for rightTable groups.\n :return: (io.deephaven.qst.table.JoinTable) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 3* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (io.deephaven.qst.table.JoinTable) a new table joined according to the specification in columnsToMatch and includes all non-key-columns from\n the right table\n \n*Overload 4* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (io.deephaven.qst.table.JoinTable) a new table joined according to the specification in columnsToMatch and columnsToAdd", - "leftJoin": "**Incompatible overloads text - text from the first overload:**\n\nPerform a left-join with the rightTable.\n\n \n Delegates to TableOperations.leftJoin(Object, Collection, Collection).\n\n*Overload 1* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (io.deephaven.qst.table.LeftJoinTable) the left-joined table\n \n*Overload 2* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (io.deephaven.qst.table.LeftJoinTable) the left-joined table\n \n*Overload 3* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (io.deephaven.qst.table.LeftJoinTable) a table that has one column for each original table's columns, and one column corresponding to each\n column listed in columnsToAdd. If columnsToAdd.isEmpty() one column corresponding to each column\n of the input table (right table) columns whose names don't overlap with the name of a column from the\n source table is added. The new columns (those corresponding to the input table) contain an aggregation of\n all values from the left side that match the join criteria.", "logic": ":return: io.deephaven.qst.TableCreationLogic", "naturalJoin": "**Incompatible overloads text - text from the first overload:**\n\nPerform a natural-join with the rightTable.\n\n \n Delegates to TableOperations.naturalJoin(Object, Collection, Collection).\n\n*Overload 1* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (io.deephaven.qst.table.NaturalJoinTable) the natural-joined table\n \n*Overload 2* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :return: (io.deephaven.qst.table.NaturalJoinTable) the natural-joined table\n \n*Overload 3* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\")\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the right side that need to be added to the left\n side as a result of the match.\n :return: (io.deephaven.qst.table.NaturalJoinTable) the natural-joined table", "raj": "**Incompatible overloads text - text from the first overload:**\n\nPerform a reverse-as-of join with the rightTable.\n\n \n Delegates to TableOperations.raj(Object, Collection, Collection, ReverseAsOfJoinRule).\n\n*Overload 1* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\").\n :return: (io.deephaven.qst.table.ReverseAsOfJoinTable) a new table joined according to the specification in columnsToMatch\n \n*Overload 2* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.lang.String) - A comma separated list of match conditions (\"leftColumn=rightColumn\" or\n \"columnFoundInBoth\").\n :param columnsToAdd: (java.lang.String) - A comma separated list with the columns from the left side that need to be added to the right\n side as a result of the match.\n :return: (io.deephaven.qst.table.ReverseAsOfJoinTable) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 3* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :return: (io.deephaven.qst.table.ReverseAsOfJoinTable) a new table joined according to the specification in columnsToMatch and columnsToAdd\n \n*Overload 4* \n :param rightTable: (io.deephaven.qst.table.TableSpec) - The right side table on the join.\n :param columnsToMatch: (java.util.Collection) - The match pair conditions.\n :param columnsToAdd: (java.util.Collection) - The columns from the right side that need to be added to the left side as a result of the\n match.\n :param reverseAsOfJoinRule: (io.deephaven.api.ReverseAsOfJoinRule) - The binary search operator for the last match pair.\n :return: (io.deephaven.qst.table.ReverseAsOfJoinTable) a new table joined according to the specification in columnsToMatch and columnsToAdd", diff --git a/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableSpec/Visitor.json b/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableSpec/Visitor.json index 6620f97466b..9f6ba45cca5 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableSpec/Visitor.json +++ b/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableSpec/Visitor.json @@ -1,7 +1,7 @@ { "className": "io.deephaven.qst.table.TableSpec$Visitor", "methods": { - "visit": "*Overload 1* \n :param emptyTable: io.deephaven.qst.table.EmptyTable\n \n*Overload 2* \n :param newTable: io.deephaven.qst.table.NewTable\n \n*Overload 3* \n :param timeTable: io.deephaven.qst.table.TimeTable\n \n*Overload 4* \n :param mergeTable: io.deephaven.qst.table.MergeTable\n \n*Overload 5* \n :param headTable: io.deephaven.qst.table.HeadTable\n \n*Overload 6* \n :param tailTable: io.deephaven.qst.table.TailTable\n \n*Overload 7* \n :param reverseTable: io.deephaven.qst.table.ReverseTable\n \n*Overload 8* \n :param sortTable: io.deephaven.qst.table.SortTable\n \n*Overload 9* \n :param snapshotTable: io.deephaven.qst.table.SnapshotTable\n \n*Overload 10* \n :param whereTable: io.deephaven.qst.table.WhereTable\n \n*Overload 11* \n :param whereInTable: io.deephaven.qst.table.WhereInTable\n \n*Overload 12* \n :param whereNotInTable: io.deephaven.qst.table.WhereNotInTable\n \n*Overload 13* \n :param naturalJoinTable: io.deephaven.qst.table.NaturalJoinTable\n \n*Overload 14* \n :param exactJoinTable: io.deephaven.qst.table.ExactJoinTable\n \n*Overload 15* \n :param joinTable: io.deephaven.qst.table.JoinTable\n \n*Overload 16* \n :param leftJoinTable: io.deephaven.qst.table.LeftJoinTable\n \n*Overload 17* \n :param aj: io.deephaven.qst.table.AsOfJoinTable\n \n*Overload 18* \n :param raj: io.deephaven.qst.table.ReverseAsOfJoinTable\n \n*Overload 19* \n :param viewTable: io.deephaven.qst.table.ViewTable\n \n*Overload 20* \n :param selectTable: io.deephaven.qst.table.SelectTable\n \n*Overload 21* \n :param updateViewTable: io.deephaven.qst.table.UpdateViewTable\n \n*Overload 22* \n :param updateTable: io.deephaven.qst.table.UpdateTable\n \n*Overload 23* \n :param groupByTable: io.deephaven.qst.table.GroupByTable\n \n*Overload 24* \n :param aggregationTable: io.deephaven.qst.table.AggregationTable\n \n*Overload 25* \n :param ticketTable: io.deephaven.qst.table.TicketTable\n \n*Overload 26* \n :param inputTable: io.deephaven.qst.table.InputTable" + "visit": "*Overload 1* \n :param emptyTable: io.deephaven.qst.table.EmptyTable\n \n*Overload 2* \n :param newTable: io.deephaven.qst.table.NewTable\n \n*Overload 3* \n :param timeTable: io.deephaven.qst.table.TimeTable\n \n*Overload 4* \n :param mergeTable: io.deephaven.qst.table.MergeTable\n \n*Overload 5* \n :param headTable: io.deephaven.qst.table.HeadTable\n \n*Overload 6* \n :param tailTable: io.deephaven.qst.table.TailTable\n \n*Overload 7* \n :param reverseTable: io.deephaven.qst.table.ReverseTable\n \n*Overload 8* \n :param sortTable: io.deephaven.qst.table.SortTable\n \n*Overload 9* \n :param snapshotTable: io.deephaven.qst.table.SnapshotTable\n \n*Overload 10* \n :param whereTable: io.deephaven.qst.table.WhereTable\n \n*Overload 11* \n :param whereInTable: io.deephaven.qst.table.WhereInTable\n \n*Overload 12* \n :param whereNotInTable: io.deephaven.qst.table.WhereNotInTable\n \n*Overload 13* \n :param naturalJoinTable: io.deephaven.qst.table.NaturalJoinTable\n \n*Overload 14* \n :param exactJoinTable: io.deephaven.qst.table.ExactJoinTable\n \n*Overload 15* \n :param joinTable: io.deephaven.qst.table.JoinTable\n \n*Overload 16* \n :param aj: io.deephaven.qst.table.AsOfJoinTable\n \n*Overload 17* \n :param raj: io.deephaven.qst.table.ReverseAsOfJoinTable\n \n*Overload 18* \n :param viewTable: io.deephaven.qst.table.ViewTable\n \n*Overload 19* \n :param selectTable: io.deephaven.qst.table.SelectTable\n \n*Overload 20* \n :param updateViewTable: io.deephaven.qst.table.UpdateViewTable\n \n*Overload 21* \n :param updateTable: io.deephaven.qst.table.UpdateTable\n \n*Overload 22* \n :param groupByTable: io.deephaven.qst.table.GroupByTable\n \n*Overload 23* \n :param aggregationTable: io.deephaven.qst.table.AggregationTable\n \n*Overload 24* \n :param ticketTable: io.deephaven.qst.table.TicketTable\n \n*Overload 25* \n :param inputTable: io.deephaven.qst.table.InputTable" }, "path": "io.deephaven.qst.table.TableSpec.Visitor", "typeName": "interface" diff --git a/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableVisitorGeneric.json b/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableVisitorGeneric.json index a933ffb5fbd..d8603581227 100644 --- a/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableVisitorGeneric.json +++ b/Integrations/python/deephaven/doc/io/deephaven/qst/table/TableVisitorGeneric.json @@ -2,7 +2,7 @@ "className": "io.deephaven.qst.table.TableVisitorGeneric", "methods": { "accept": ":param t: io.deephaven.qst.table.TableSpec", - "visit": "*Overload 1* \n :param emptyTable: io.deephaven.qst.table.EmptyTable\n \n*Overload 2* \n :param newTable: io.deephaven.qst.table.NewTable\n \n*Overload 3* \n :param timeTable: io.deephaven.qst.table.TimeTable\n \n*Overload 4* \n :param mergeTable: io.deephaven.qst.table.MergeTable\n \n*Overload 5* \n :param headTable: io.deephaven.qst.table.HeadTable\n \n*Overload 6* \n :param tailTable: io.deephaven.qst.table.TailTable\n \n*Overload 7* \n :param reverseTable: io.deephaven.qst.table.ReverseTable\n \n*Overload 8* \n :param sortTable: io.deephaven.qst.table.SortTable\n \n*Overload 9* \n :param snapshotTable: io.deephaven.qst.table.SnapshotTable\n \n*Overload 10* \n :param whereTable: io.deephaven.qst.table.WhereTable\n \n*Overload 11* \n :param whereInTable: io.deephaven.qst.table.WhereInTable\n \n*Overload 12* \n :param whereNotInTable: io.deephaven.qst.table.WhereNotInTable\n \n*Overload 13* \n :param naturalJoinTable: io.deephaven.qst.table.NaturalJoinTable\n \n*Overload 14* \n :param exactJoinTable: io.deephaven.qst.table.ExactJoinTable\n \n*Overload 15* \n :param joinTable: io.deephaven.qst.table.JoinTable\n \n*Overload 16* \n :param leftJoinTable: io.deephaven.qst.table.LeftJoinTable\n \n*Overload 17* \n :param aj: io.deephaven.qst.table.AsOfJoinTable\n \n*Overload 18* \n :param raj: io.deephaven.qst.table.ReverseAsOfJoinTable\n \n*Overload 19* \n :param viewTable: io.deephaven.qst.table.ViewTable\n \n*Overload 20* \n :param selectTable: io.deephaven.qst.table.SelectTable\n \n*Overload 21* \n :param updateViewTable: io.deephaven.qst.table.UpdateViewTable\n \n*Overload 22* \n :param updateTable: io.deephaven.qst.table.UpdateTable\n \n*Overload 23* \n :param groupByTable: io.deephaven.qst.table.GroupByTable\n \n*Overload 24* \n :param aggregationTable: io.deephaven.qst.table.AggregationTable\n \n*Overload 25* \n :param ticketTable: io.deephaven.qst.table.TicketTable\n \n*Overload 26* \n :param inputTable: io.deephaven.qst.table.InputTable" + "visit": "*Overload 1* \n :param emptyTable: io.deephaven.qst.table.EmptyTable\n \n*Overload 2* \n :param newTable: io.deephaven.qst.table.NewTable\n \n*Overload 3* \n :param timeTable: io.deephaven.qst.table.TimeTable\n \n*Overload 4* \n :param mergeTable: io.deephaven.qst.table.MergeTable\n \n*Overload 5* \n :param headTable: io.deephaven.qst.table.HeadTable\n \n*Overload 6* \n :param tailTable: io.deephaven.qst.table.TailTable\n \n*Overload 7* \n :param reverseTable: io.deephaven.qst.table.ReverseTable\n \n*Overload 8* \n :param sortTable: io.deephaven.qst.table.SortTable\n \n*Overload 9* \n :param snapshotTable: io.deephaven.qst.table.SnapshotTable\n \n*Overload 10* \n :param whereTable: io.deephaven.qst.table.WhereTable\n \n*Overload 11* \n :param whereInTable: io.deephaven.qst.table.WhereInTable\n \n*Overload 12* \n :param whereNotInTable: io.deephaven.qst.table.WhereNotInTable\n \n*Overload 13* \n :param naturalJoinTable: io.deephaven.qst.table.NaturalJoinTable\n \n*Overload 14* \n :param exactJoinTable: io.deephaven.qst.table.ExactJoinTable\n \n*Overload 15* \n :param joinTable: io.deephaven.qst.table.JoinTable\n \n*Overload 16* \n :param aj: io.deephaven.qst.table.AsOfJoinTable\n \n*Overload 17* \n :param raj: io.deephaven.qst.table.ReverseAsOfJoinTable\n \n*Overload 18* \n :param viewTable: io.deephaven.qst.table.ViewTable\n \n*Overload 19* \n :param selectTable: io.deephaven.qst.table.SelectTable\n \n*Overload 20* \n :param updateViewTable: io.deephaven.qst.table.UpdateViewTable\n \n*Overload 21* \n :param updateTable: io.deephaven.qst.table.UpdateTable\n \n*Overload 22* \n :param groupByTable: io.deephaven.qst.table.GroupByTable\n \n*Overload 23* \n :param aggregationTable: io.deephaven.qst.table.AggregationTable\n \n*Overload 24* \n :param ticketTable: io.deephaven.qst.table.TicketTable\n \n*Overload 25* \n :param inputTable: io.deephaven.qst.table.InputTable" }, "path": "io.deephaven.qst.table.TableVisitorGeneric", "typeName": "class" diff --git a/cpp-client/deephaven/client/include/private/deephaven/client/highlevel/impl/table_handle_impl.h b/cpp-client/deephaven/client/include/private/deephaven/client/highlevel/impl/table_handle_impl.h index 2323c3c926a..de981ab6976 100644 --- a/cpp-client/deephaven/client/include/private/deephaven/client/highlevel/impl/table_handle_impl.h +++ b/cpp-client/deephaven/client/include/private/deephaven/client/highlevel/impl/table_handle_impl.h @@ -162,9 +162,6 @@ class TableHandleImpl { std::shared_ptr exactJoin(const TableHandleImpl &rightSide, std::vector columnsToMatch, std::vector columnsToAdd) const; - std::shared_ptr leftJoin(const TableHandleImpl &rightSide, - std::vector columnsToMatch, std::vector columnsToAdd) const; - std::shared_ptr asOfJoin(AsOfJoinTablesRequest::MatchRule matchRule, const TableHandleImpl &rightSide, std::vector columnsToMatch, std::vector columnsToAdd); diff --git a/cpp-client/deephaven/client/include/private/deephaven/client/lowlevel/server.h b/cpp-client/deephaven/client/include/private/deephaven/client/lowlevel/server.h index bc15998506e..c629f6b4fc5 100644 --- a/cpp-client/deephaven/client/include/private/deephaven/client/lowlevel/server.h +++ b/cpp-client/deephaven/client/include/private/deephaven/client/lowlevel/server.h @@ -180,10 +180,6 @@ class Server { std::vector columnsToMatch, std::vector columnsToAdd, std::shared_ptr etcCallback); - Ticket leftJoinAsync(Ticket leftTableTicket, Ticket rightTableTicket, - std::vector columnsToMatch, std::vector columnsToAdd, - std::shared_ptr etcCallback); - Ticket asOfJoinAsync(AsOfJoinTablesRequest::MatchRule matchRule, Ticket leftTableTicket, Ticket rightTableTicket, std::vector columnsToMatch, std::vector columnsToAdd, std::shared_ptr etcCallback); diff --git a/cpp-client/deephaven/client/include/public/deephaven/client/highlevel/client.h b/cpp-client/deephaven/client/include/public/deephaven/client/highlevel/client.h index 4edd3221d0a..f05cf283f82 100644 --- a/cpp-client/deephaven/client/include/public/deephaven/client/highlevel/client.h +++ b/cpp-client/deephaven/client/include/public/deephaven/client/highlevel/client.h @@ -962,7 +962,7 @@ class TableHandle { * the columns in `columnsToMatch`, and columns from `rightSide` are brought in and optionally * renamed by `columnsToAdd`. Example: * @code - * t1.naturalJoin({"Col1", "Col2"}, {"Col3", "NewCol=Col4"}) + * t1.exactJoin({"Col1", "Col2"}, {"Col3", "NewCol=Col4"}) * @endcode * @param rightSide The table to join with this table * @param columnsToMatch The columns to join on @@ -985,34 +985,6 @@ class TableHandle { TableHandle exactJoin(const TableHandle &rightSide, std::vector columnsToMatch, std::vector columnsToAdd) const; - /** - * Creates a new table by left joining this table with `rightSide`. The tables are joined by - * the columns in `columnsToMatch`, and columns from `rightSide` are brought in and optionally - * renamed by `columnsToAdd`. Example: - * @code - * t1.naturalJoin({"Col1", "Col2"}, {"Col3", "NewCol=Col4"}) - * @endcode - * @param rightSide The table to join with this table - * @param columnsToMatch The columns to join on - * @param columnsToAdd The columns from the right side to add, and possibly rename. - * @return A TableHandle referencing the new table - */ - TableHandle leftJoin(const TableHandle &rightSide, std::vector columnsToMatch, - std::vector columnsToAdd) const; - /** - * The fluent version of leftJoin(const TableHandle &, std::vector, std::vector) const. - * @code - * t1.leftJoin(col1, col2}, {col3, col4.as("NewCol"}) - * @endcode - - * @param rightSide The table to join with this table - * @param columnsToMatch The columns to join on - * @param columnsToAdd The columns from the right side to add, and possibly rename. - * @return - */ - TableHandle leftJoin(const TableHandle &rightSide, std::vector columnsToMatch, - std::vector columnsToAdd) const; - /** * Binds this table to a variable name in the QueryScope. * @param variable diff --git a/cpp-client/deephaven/client/src/highlevel/client.cc b/cpp-client/deephaven/client/src/highlevel/client.cc index d5dbacc65eb..947d935e29c 100644 --- a/cpp-client/deephaven/client/src/highlevel/client.cc +++ b/cpp-client/deephaven/client/src/highlevel/client.cc @@ -495,20 +495,6 @@ TableHandle TableHandle::exactJoin(const TableHandle &rightSide, return exactJoin(rightSide, std::move(ctmStrings), std::move(ctaStrings)); } -TableHandle TableHandle::leftJoin(const TableHandle &rightSide, - std::vector columnsToMatch, std::vector columnsToAdd) const { - auto qtImpl = impl_->leftJoin(*rightSide.impl_, std::move(columnsToMatch), - std::move(columnsToAdd)); - return TableHandle(std::move(qtImpl)); -} - -TableHandle TableHandle::leftJoin(const TableHandle &rightSide, - std::vector columnsToMatch, std::vector columnsToAdd) const { - auto ctmStrings = toIrisRepresentation(columnsToMatch); - auto ctaStrings = toIrisRepresentation(columnsToAdd); - return leftJoin(rightSide, std::move(ctmStrings), std::move(ctaStrings)); -} - void TableHandle::bindToVariable(std::string variable) const { auto res = SFCallback<>::createForFuture(); bindToVariableAsync(std::move(variable), std::move(res.first)); diff --git a/cpp-client/deephaven/client/src/highlevel/impl/table_handle_impl.cc b/cpp-client/deephaven/client/src/highlevel/impl/table_handle_impl.cc index da68664592d..5948295e335 100644 --- a/cpp-client/deephaven/client/src/highlevel/impl/table_handle_impl.cc +++ b/cpp-client/deephaven/client/src/highlevel/impl/table_handle_impl.cc @@ -303,14 +303,6 @@ std::shared_ptr TableHandleImpl::exactJoin(const TableHandleImp return TableHandleImpl::create(managerImpl_, std::move(resultTicket), std::move(cb)); } -std::shared_ptr TableHandleImpl::leftJoin(const TableHandleImpl &rightSide, - std::vector columnsToMatch, std::vector columnsToAdd) const { - auto cb = TableHandleImpl::createEtcCallback(managerImpl_.get()); - auto resultTicket = managerImpl_->server()->leftJoinAsync(ticket_, rightSide.ticket_, - std::move(columnsToMatch), std::move(columnsToAdd), cb); - return TableHandleImpl::create(managerImpl_, std::move(resultTicket), std::move(cb)); -} - std::shared_ptr TableHandleImpl::asOfJoin(AsOfJoinTablesRequest::MatchRule matchRule, const TableHandleImpl &rightSide, std::vector columnsToMatch, std::vector columnsToAdd) { diff --git a/cpp-client/deephaven/client/src/lowlevel/server.cc b/cpp-client/deephaven/client/src/lowlevel/server.cc index 2c20d1f819e..3092d5dea66 100644 --- a/cpp-client/deephaven/client/src/lowlevel/server.cc +++ b/cpp-client/deephaven/client/src/lowlevel/server.cc @@ -27,7 +27,6 @@ using io::deephaven::proto::backplane::grpc::FetchTableRequest; using io::deephaven::proto::backplane::grpc::HandshakeRequest; using io::deephaven::proto::backplane::grpc::HeadOrTailRequest; using io::deephaven::proto::backplane::grpc::HeadOrTailByRequest; -using io::deephaven::proto::backplane::grpc::LeftJoinTablesRequest; using io::deephaven::proto::backplane::grpc::MergeTablesRequest; using io::deephaven::proto::backplane::grpc::NaturalJoinTablesRequest; using io::deephaven::proto::backplane::grpc::SelectOrUpdateRequest; @@ -361,20 +360,6 @@ Ticket Server::exactJoinAsync(Ticket leftTableTicket, Ticket rightTableTicket, return result; } -Ticket Server::leftJoinAsync(Ticket leftTableTicket, Ticket rightTableTicket, - std::vector columnsToMatch, std::vector columnsToAdd, - std::shared_ptr etcCallback) { - auto result = newTicket(); - LeftJoinTablesRequest req; - *req.mutable_result_id() = result; - *req.mutable_left_id()->mutable_ticket() = std::move(leftTableTicket); - *req.mutable_right_id()->mutable_ticket() = std::move(rightTableTicket); - moveVectorData(std::move(columnsToMatch), req.mutable_columns_to_match()); - moveVectorData(std::move(columnsToAdd), req.mutable_columns_to_add()); - sendRpc(req, std::move(etcCallback), tableStub(), &TableService::Stub::AsyncLeftJoinTables, true); - return result; -} - Ticket Server::asOfJoinAsync(AsOfJoinTablesRequest::MatchRule matchRule, Ticket leftTableTicket, Ticket rightTableTicket, std::vector columnsToMatch, std::vector columnsToAdd, std::shared_ptr etcCallback) { diff --git a/engine/api/src/main/java/io/deephaven/engine/table/Table.java b/engine/api/src/main/java/io/deephaven/engine/table/Table.java index 12fac319f64..ef14ed1cdff 100644 --- a/engine/api/src/main/java/io/deephaven/engine/table/Table.java +++ b/engine/api/src/main/java/io/deephaven/engine/table/Table.java @@ -556,44 +556,6 @@ public interface Table extends // Join Operations // ----------------------------------------------------------------------------------------------------------------- - /** - * Returns a table that has one column for each original table's columns, and one column corresponding to each of - * the input table (right table) columns listed in the columns to add (or all the columns whose names don't overlap - * with the name of a column from the source table if the columnsToAdd is length zero). The new columns (those - * corresponding to the input table) contain an aggregation of all values from the left side that match the join - * criteria. Consequently, the types of all right side columns not involved in a join criteria, is an array of the - * original column type. If the two tables have columns with matching names then the method will fail with an - * exception unless the columns with corresponding names are found in one of the matching criteria. - *

- *

- * NOTE: leftJoin operation does not involve an actual data copy, or an in-memory table creation. In order to - * produce an actual in memory table you need to apply a select call on the join result. - * - * @param rightTable input table - * @param columnsToMatch match criteria - * @param columnsToAdd columns to add - * @return a table that has one column for each original table's columns, and one column corresponding to each - * column listed in columnsToAdd. If columnsToAdd.length==0 one column corresponding to each column of the - * input table (right table) columns whose names don't overlap with the name of a column from the source - * table is added. The new columns (those corresponding to the input table) contain an aggregation of all - * values from the left side that match the join criteria. - */ - Table leftJoin(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd); - - @Override - Table leftJoin(Table rightTable, Collection columnsToMatch, - Collection columnsToAdd); - - Table leftJoin(Table rightTable, Collection columnsToMatch); - - @Override - Table leftJoin(Table rightTable, String columnsToMatch, String columnsToAdd); - - @Override - Table leftJoin(Table rightTable, String columnsToMatch); - - Table leftJoin(Table rightTable); - Table exactJoin(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd); @Override diff --git a/engine/benchmark/src/benchmark/java/io/deephaven/benchmark/engine/MultiTableKeyedOperations.java b/engine/benchmark/src/benchmark/java/io/deephaven/benchmark/engine/MultiTableKeyedOperations.java index 40d90987977..1c21aaca914 100644 --- a/engine/benchmark/src/benchmark/java/io/deephaven/benchmark/engine/MultiTableKeyedOperations.java +++ b/engine/benchmark/src/benchmark/java/io/deephaven/benchmark/engine/MultiTableKeyedOperations.java @@ -50,7 +50,6 @@ public class MultiTableKeyedOperations { private String[] keyColumns; private String columnsToMatch; - @Setup(Level.Trial) public void setupEnv(BenchmarkParams params) { int columnCount = 1 << logColumnCount; @@ -80,26 +79,17 @@ public void setupEnv(BenchmarkParams params) { .lastBy(keyColumns).select(); } - @Setup(Level.Iteration) public void setupIteration() { state.init(); } - @Benchmark public Table naturalJoin() { - Table result = fullTable.naturalJoin(distinctTable, columnsToMatch); return result; } - @Benchmark - public Table leftJoin() { - - return distinctTable.leftJoin(fullTable, columnsToMatch); - } - public static void main(String[] args) { BenchUtil.run(MultiTableKeyedOperations.class); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/Attributes.java b/engine/chunk/src/main/java/io/deephaven/chunk/Attributes.java deleted file mode 100644 index 456a7e4b719..00000000000 --- a/engine/chunk/src/main/java/io/deephaven/chunk/Attributes.java +++ /dev/null @@ -1,11 +0,0 @@ -package io.deephaven.chunk; - -import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.attributes.Values; - -/** - * Attributes that may apply to a {@link Chunk}. - */ -public class Attributes { - -} diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/Chunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/Chunk.java index 3589ab5cc87..ede8b828196 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/Chunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/Chunk.java @@ -8,7 +8,7 @@ /** * Data structure for a contiguous region of data. * - * @param {@link Attributes} that apply to this chunk + * @param Descriptive attribute that applies to the elements stored within this Chunk */ public interface Chunk { /** diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableChunk.java index d43a2e9dbf4..9db23f9a798 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableChunk.java @@ -9,7 +9,7 @@ /** * Data structure for a contiguous region of data that may be mutated. * - * @param {@link Attributes} that apply to this chunk + * @param Descriptive attribute that applies to the elements stored within this WritableChunk */ public interface WritableChunk extends Chunk, PoolableChunk { @Override diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/HierarchicalTable.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/HierarchicalTable.java index ab91c8fd89d..560da1917b8 100644 --- a/engine/table/src/main/java/io/deephaven/engine/table/impl/HierarchicalTable.java +++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/HierarchicalTable.java @@ -115,11 +115,6 @@ public Table tail(long size) { return throwUnsupported("tail()"); } - @Override - public Table leftJoin(Table table, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd) { - return throwUnsupported("leftJoin()"); - } - @Override public Table exactJoin(Table table, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd) { return throwUnsupported("exactJoin()"); diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/QueryTable.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/QueryTable.java index 08cc4b3ef02..434dba68601 100644 --- a/engine/table/src/main/java/io/deephaven/engine/table/impl/QueryTable.java +++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/QueryTable.java @@ -560,22 +560,6 @@ public Table tailPct(final double percent) { return getResult(SliceLikeOperation.tailPct(this, percent)); } - @Override - public Table leftJoin(Table table, final MatchPair[] columnsToMatch, final MatchPair[] columnsToAdd) { - return QueryPerformanceRecorder.withNugget( - "leftJoin(" + table + "," + matchString(columnsToMatch) + "," + matchString(columnsToAdd) + ")", - sizeForInstrumentation(), () -> { - String[] rightColumnKeys = new String[columnsToMatch.length]; - for (int i = 0; i < columnsToMatch.length; i++) { - MatchPair match = columnsToMatch[i]; - rightColumnKeys[i] = match.rightColumn; - } - - Table groupedRight = table.groupBy(rightColumnKeys); - return naturalJoin(groupedRight, columnsToMatch, columnsToAdd); - }); - } - @Override public Table exactJoin(Table table, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd) { return QueryPerformanceRecorder.withNugget( diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/TableMapProxyHandler.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/TableMapProxyHandler.java index 2e9e7b5f257..9b7bac62755 100644 --- a/engine/table/src/main/java/io/deephaven/engine/table/impl/TableMapProxyHandler.java +++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/TableMapProxyHandler.java @@ -69,7 +69,6 @@ public class TableMapProxyHandler extends LivenessArtifact implements Invocation JOIN_METHOD_NAMES.add("join"); JOIN_METHOD_NAMES.add("naturalJoin"); - JOIN_METHOD_NAMES.add("leftJoin"); JOIN_METHOD_NAMES.add("exactJoin"); AJ_METHOD_NAMES.add("aj"); AJ_METHOD_NAMES.add("raj"); diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/TableWithDefaults.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/TableWithDefaults.java index c00f2ee4c75..0e8133c152b 100644 --- a/engine/table/src/main/java/io/deephaven/engine/table/impl/TableWithDefaults.java +++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/TableWithDefaults.java @@ -398,41 +398,6 @@ default Table dateTimeColumnAsNanos(String columnName) { // Join Operations // ----------------------------------------------------------------------------------------------------------------- - @Override - default Table leftJoin(Table rightTable, Collection columnsToMatch, - Collection columnsToAdd) { - return leftJoin( - rightTable, - MatchPair.fromMatches(columnsToMatch), - MatchPair.fromAddition(columnsToAdd)); - } - - @Override - default Table leftJoin(Table rightTable, Collection columnsToMatch) { - return leftJoin( - rightTable, - MatchPairFactory.getExpressions(columnsToMatch), - MatchPair.ZERO_LENGTH_MATCH_PAIR_ARRAY); - } - - @Override - default Table leftJoin(Table rightTable, String columnsToMatch, String columnsToAdd) { - return leftJoin( - rightTable, - MatchPairFactory.getExpressions(StringUtils.splitToCollection(columnsToMatch)), - MatchPairFactory.getExpressions(StringUtils.splitToCollection(columnsToAdd))); - } - - @Override - default Table leftJoin(Table rightTable, String columnsToMatch) { - return leftJoin(rightTable, StringUtils.splitToCollection(columnsToMatch)); - } - - @Override - default Table leftJoin(Table rightTable) { - return leftJoin(rightTable, Collections.emptyList()); - } - @Override default Table exactJoin(Table rightTable, Collection columnsToMatch, Collection columnsToAdd) { diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/UncoalescedTable.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/UncoalescedTable.java index 0568090af1c..69a9be2ae5b 100644 --- a/engine/table/src/main/java/io/deephaven/engine/table/impl/UncoalescedTable.java +++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/UncoalescedTable.java @@ -307,11 +307,6 @@ public Table tailPct(double percent) { return coalesce().tailPct(percent); } - @Override - public Table leftJoin(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd) { - return coalesce().leftJoin(rightTable, columnsToMatch, columnsToAdd); - } - @Override public Table exactJoin(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd) { return coalesce().exactJoin(rightTable, columnsToMatch, columnsToAdd); diff --git a/engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableJoinTest.java b/engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableJoinTest.java index b037ac77b1d..612e20ea9d4 100644 --- a/engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableJoinTest.java +++ b/engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableJoinTest.java @@ -884,21 +884,15 @@ public void testJoin() { } @Test - public void testLeftJoin() { + public void testNaturalJoinWithGroupBy() { Table table1 = newTable( c("String", "c", "e", "g")); Table table2 = newTable(c("String", "c", "e"), c("v", 1, 2), c("u", 3.0d, 4.0d)); - try { - table1.leftJoin(table2); - fail("Previous statement should have thrown an exception"); - } catch (Exception e) { - assertEquals("Conflicting column names [String]", e.getMessage()); - } showWithRowSet(table1); showWithRowSet(table2); - Table pairMatch = table1.leftJoin(table2, "String"); + Table pairMatch = table1.naturalJoin(table2.groupBy("String"), "String"); showWithRowSet(pairMatch); @@ -924,7 +918,7 @@ public void testLeftJoin() { assertEquals(1, uValues[1].size()); assertNull(vValues[2]); - pairMatch = table1.leftJoin(table2, "String", "v"); + pairMatch = table1.naturalJoin(table2.groupBy("String"), "String", "v"); assertEquals(3, pairMatch.size()); assertEquals(2, pairMatch.getColumns().length); assertEquals("String", pairMatch.getColumns()[0].getName()); @@ -939,7 +933,7 @@ public void testLeftJoin() { assertEquals(1, vValues[1].size()); assertNull(vValues[2]); - pairMatch = table1.leftJoin(table2, "String", "u,v"); + pairMatch = table1.naturalJoin(table2.groupBy("String"), "String", "u,v"); assertEquals(3, pairMatch.size()); assertEquals(3, pairMatch.getColumns().length); assertEquals("String", pairMatch.getColumns()[0].getName()); @@ -962,7 +956,7 @@ public void testLeftJoin() { assertEquals(1, uValues[1].size()); assertNull(vValues[2]); - pairMatch = table2.leftJoin(table1, "String"); + pairMatch = table2.naturalJoin(table1.groupBy("String"), "String"); assertEquals(2, pairMatch.size()); assertEquals(3, pairMatch.getColumns().length); @@ -975,7 +969,7 @@ public void testLeftJoin() { assertEquals(1, pairMatch.getColumn("v").getInt(0)); assertEquals(2, pairMatch.getColumn("v").getInt(1)); - pairMatch = table1.leftJoin(table2, "String=String"); + pairMatch = table1.naturalJoin(table2.groupBy("String"), "String=String"); assertEquals(3, pairMatch.size()); assertEquals(3, pairMatch.getColumns().length); assertEquals("String", pairMatch.getColumns()[0].getName()); @@ -990,7 +984,7 @@ public void testLeftJoin() { assertEquals(1, vValues[1].size()); assertNull(vValues[2]); - pairMatch = table2.leftJoin(table1, "String=String"); + pairMatch = table2.naturalJoin(table1.groupBy("String"), "String=String"); assertEquals(2, pairMatch.size()); assertEquals(3, pairMatch.getColumns().length); @@ -1009,7 +1003,7 @@ public void testLeftJoin() { table2 = TableTools.newTable( c("String2", "c", "e"), c("v", 1, 2)); - final Table noPairMatch = table1.leftJoin(table2); + final Table noPairMatch = table1.naturalJoin(table2.groupBy(), ""); assertEquals(3, noPairMatch.size()); assertEquals(3, noPairMatch.getColumns().length); assertEquals("String1", noPairMatch.getColumns()[0].getName()); @@ -1030,7 +1024,7 @@ public void testLeftJoin() { assertEquals(asList(1, 2), asList(ArrayTypeUtils.getBoxedArray(vValues[1].toArray()))); assertEquals(asList(1, 2), asList(ArrayTypeUtils.getBoxedArray(vValues[2].toArray()))); - pairMatch = table1.leftJoin(table2, "String1=String2"); + pairMatch = table1.naturalJoin(table2.groupBy("String2"), "String1=String2"); assertEquals(3, pairMatch.size()); assertEquals(3, pairMatch.getColumns().length); assertEquals("String1", pairMatch.getColumns()[0].getName()); @@ -1053,7 +1047,7 @@ public void testLeftJoin() { assertEquals(1, vValues[1].size()); assertNull(vValues[2]); - pairMatch = table2.leftJoin(table1, "String2=String1"); + pairMatch = table2.naturalJoin(table1.groupBy("String1"), "String2=String1"); assertEquals(2, pairMatch.size()); assertEquals(3, pairMatch.getColumns().length); diff --git a/grpc-api/src/main/java/io/deephaven/grpc_api/table/ops/JoinTablesGrpcImpl.java b/grpc-api/src/main/java/io/deephaven/grpc_api/table/ops/JoinTablesGrpcImpl.java index 803043ee5f4..c8f491c24d1 100644 --- a/grpc-api/src/main/java/io/deephaven/grpc_api/table/ops/JoinTablesGrpcImpl.java +++ b/grpc-api/src/main/java/io/deephaven/grpc_api/table/ops/JoinTablesGrpcImpl.java @@ -192,7 +192,8 @@ public LeftJoinTablesGrpcImpl(final UpdateGraphProcessor updateGraphProcessor) { public static Table doJoin(final Table lhs, final Table rhs, final MatchPair[] columnsToMatch, final MatchPair[] columnsToAdd, final LeftJoinTablesRequest request) { - return lhs.leftJoin(rhs, columnsToMatch, columnsToAdd); + throw GrpcUtil.statusRuntimeException(Code.UNIMPLEMENTED, + "LeftJoinTables is currently unimplemented"); } } diff --git a/java-client/session/src/main/java/io/deephaven/client/impl/BatchTableRequestBuilder.java b/java-client/session/src/main/java/io/deephaven/client/impl/BatchTableRequestBuilder.java index f9be9efccc3..7c1d12ba6ea 100644 --- a/java-client/session/src/main/java/io/deephaven/client/impl/BatchTableRequestBuilder.java +++ b/java-client/session/src/main/java/io/deephaven/client/impl/BatchTableRequestBuilder.java @@ -66,7 +66,6 @@ import io.deephaven.proto.backplane.grpc.FilterTableRequest; import io.deephaven.proto.backplane.grpc.HeadOrTailRequest; import io.deephaven.proto.backplane.grpc.IsNullCondition; -import io.deephaven.proto.backplane.grpc.LeftJoinTablesRequest; import io.deephaven.proto.backplane.grpc.Literal; import io.deephaven.proto.backplane.grpc.MergeTablesRequest; import io.deephaven.proto.backplane.grpc.NaturalJoinTablesRequest; @@ -318,19 +317,6 @@ public void visit(JoinTable j) { out = op(Builder::setCrossJoin, builder.build()); } - @Override - public void visit(LeftJoinTable j) { - LeftJoinTablesRequest.Builder builder = LeftJoinTablesRequest.newBuilder() - .setResultId(ticket).setLeftId(ref(j.left())).setRightId(ref(j.right())); - for (JoinMatch match : j.matches()) { - builder.addColumnsToMatch(Strings.of(match)); - } - for (JoinAddition addition : j.additions()) { - builder.addColumnsToAdd(Strings.of(addition)); - } - out = op(Builder::setLeftJoin, builder.build()); - } - @Override public void visit(AsOfJoinTable aj) { AsOfJoinTablesRequest.Builder builder = AsOfJoinTablesRequest.newBuilder() diff --git a/open-api/lang-tools/src/main/java/io/deephaven/lang/completion/ChunkerCompleter.java b/open-api/lang-tools/src/main/java/io/deephaven/lang/completion/ChunkerCompleter.java index 2f3b3eec0af..47908d13a57 100644 --- a/open-api/lang-tools/src/main/java/io/deephaven/lang/completion/ChunkerCompleter.java +++ b/open-api/lang-tools/src/main/java/io/deephaven/lang/completion/ChunkerCompleter.java @@ -947,7 +947,6 @@ private void methodArgumentCompletion( switch (name) { case "join": case "naturalJoin": - case "leftJoin": case "exactJoin": case "aj": // TODO: joins will need special handling; IDS-1517-5 example from Charles: diff --git a/pyclient/pydeephaven/_table_interface.py b/pyclient/pydeephaven/_table_interface.py index 59450ff530c..181ba9706f4 100644 --- a/pyclient/pydeephaven/_table_interface.py +++ b/pyclient/pydeephaven/_table_interface.py @@ -11,7 +11,7 @@ from pydeephaven.combo_agg import ComboAggregation from pydeephaven._table_ops import UpdateOp, LazyUpdateOp, ViewOp, UpdateViewOp, SelectOp, DropColumnsOp, \ SelectDistinctOp, SortOp, UnstructuredFilterOp, HeadOp, TailOp, HeadByOp, TailByOp, UngroupOp, NaturalJoinOp, \ - ExactJoinOp, LeftJoinOp, CrossJoinOp, AsOfJoinOp, DedicatedAggOp, ComboAggOp + ExactJoinOp, CrossJoinOp, AsOfJoinOp, DedicatedAggOp, ComboAggOp from pydeephaven.constants import MatchRule, SortDirection from pydeephaven._constants import AggType @@ -233,26 +233,6 @@ def exact_join(self, table: Any, on: List[str], joins: List[str] = []): table_op = ExactJoinOp(table=table, keys=on, columns_to_add=joins) return self.table_op_handler(table_op) - def left_join(self, table: Any, on: List[str], joins: List[str] = []): - """ Perform a left-join between this table as the left table and another table as the right table) and - returns the result table. - - Args: - table (Table): the right-table of the join - on (List[str]): the columns to match, can be a common name or an equal expression, - i.e. "col_a = col_b" for different column names - joins (List[str], optional): a list of the columns to be added from the right table to the result - table, can be renaming expressions, i.e. "new_col = col"; default is empty - - Returns: - a Table object - - Raises: - DHError - """ - table_op = LeftJoinOp(table=table, keys=on, columns_to_add=joins) - return self.table_op_handler(table_op) - def join(self, table: Any, on: List[str] = [], joins: List[str] = [], reserve_bits: int = 10): """ Perform a cross-join between this table as the left table and another table as the right table) and returns the result table. diff --git a/pyclient/pydeephaven/_table_ops.py b/pyclient/pydeephaven/_table_ops.py index d4cac481a73..ca1c3dd0e7b 100644 --- a/pyclient/pydeephaven/_table_ops.py +++ b/pyclient/pydeephaven/_table_ops.py @@ -365,30 +365,6 @@ def make_grpc_request_for_batch(self, result_id, source_id): exact_join=self.make_grpc_request(result_id=result_id, source_id=source_id)) -class LeftJoinOp(TableOp): - def __init__(self, table: Any, keys: List[str], columns_to_add: List[str] = []): - self.table = table - self.keys = keys - self.columns_to_add = columns_to_add - - @classmethod - def get_stub_func(cls, table_service_stub: table_pb2_grpc.TableServiceStub): - return table_service_stub.LeftJoinTables - - def make_grpc_request(self, result_id, source_id): - left_id = source_id - right_id = table_pb2.TableReference(ticket=self.table.ticket) - return table_pb2.LeftJoinTablesRequest(result_id=result_id, - left_id=left_id, - right_id=right_id, - columns_to_match=self.keys, - columns_to_add=self.columns_to_add) - - def make_grpc_request_for_batch(self, result_id, source_id): - return table_pb2.BatchTableRequest.Operation( - left_join=self.make_grpc_request(result_id=result_id, source_id=source_id)) - - class CrossJoinOp(TableOp): def __init__(self, table: Any, keys: List[str] = [], columns_to_add: List[str] = [], reserve_bits: int = 10): self.table = table diff --git a/pyclient/pydeephaven/query.py b/pyclient/pydeephaven/query.py index 4b6d89790e7..42634575b5e 100644 --- a/pyclient/pydeephaven/query.py +++ b/pyclient/pydeephaven/query.py @@ -192,21 +192,6 @@ def exact_join(self, table: Any, on: List[str], joins: List[str] = []): """ return super().exact_join(table, on, joins) - def left_join(self, table: Any, on: List[str], joins: List[str] = []): - """ Add a left-join operation to the query. - - Args: - table (Table): the right-table of the join - on (List[str]): the columns to match, can be a common name or an equal expression, - i.e. "col_a = col_b" for different column names - joins (List[str], optional): a list of the columns to be added from the right table to the result - table, can be renaming expressions, i.e. "new_col = col"; default is empty - - Returns: - self - """ - return super().left_join(table, on, joins) - def join(self, table: Any, on: List[str] = [], joins: List[str] = [], reserve_bits: int = 10): """ Add a cross-join operation to the query. diff --git a/pyclient/tests/test_table.py b/pyclient/tests/test_table.py index 32367d91f5a..3e428498130 100644 --- a/pyclient/tests/test_table.py +++ b/pyclient/tests/test_table.py @@ -118,14 +118,6 @@ def test_exact_join(self): result_table = left_table.exact_join(right_table, on=["a"], joins=["d", "e"]) self.assertEqual(test_table.size, result_table.size) - def test_left_join(self): - pa_table = csv.read_csv(self.csv_file) - test_table = self.session.import_table(pa_table) - left_table = test_table.drop_columns(["d", "e"]) - right_table = test_table.drop_columns(["b", "c"]) - result_table = left_table.left_join(right_table, on=["a"], joins=["d", "e"]) - self.assertEqual(test_table.size, result_table.size) - def test_cross_join(self): pa_table = csv.read_csv(self.csv_file) left_table = self.session.import_table(pa_table) diff --git a/pyintegration/deephaven2/table.py b/pyintegration/deephaven2/table.py index 57cd16a3f0c..b76b0ac4ccc 100644 --- a/pyintegration/deephaven2/table.py +++ b/pyintegration/deephaven2/table.py @@ -636,33 +636,6 @@ def exact_join(self, table: Table, on: List[str], joins: List[str] = []) -> Tabl except Exception as e: raise DHError(e, "table exact_join operation failed.") from e - def left_join(self, table: Table, on: List[str], joins: List[str] = []) -> Table: - """ The left_join method creates a new table containing all of the rows and columns of the left table, - plus additional columns containing data from the right table. For columns appended to the left table (joins), - row values are arrays of row values from the right table, where the key values in the left and right tables - are equal. If there is no matching key in the right table, appended row values are NULL. - - Args: - table (Table): the right-table of the join - on (List[str]): the columns to match, can be a common name or an equal expression, - i.e. "col_a = col_b" for different column names - joins (List[str], optional): a list of the columns to be added from the right table to the result - table, can be renaming expressions, i.e. "new_col = col"; default is empty - - Returns: - a new table - - Raises: - DHError - """ - try: - if joins: - return Table(j_table=self.j_table.leftJoin(table.j_table, ",".join(on), ",".join(joins))) - else: - return Table(j_table=self.j_table.leftJoin(table.j_table, ",".join(on))) - except Exception as e: - raise DHError(e, "table left_join operation failed.") from e - def join(self, table: Table, on: List[str], joins: List[str] = []) -> Table: """ The join method creates a new table containing rows that have matching values in both tables. Rows that do not have matching criteria will not be included in the result. If there are multiple matches between a row diff --git a/pyintegration/tests/test_table.py b/pyintegration/tests/test_table.py index 9ba91ea901d..d66159643e5 100644 --- a/pyintegration/tests/test_table.py +++ b/pyintegration/tests/test_table.py @@ -197,12 +197,6 @@ def test_exact_join(self): result_table = left_table.exact_join(right_table, on=["a"], joins=["d", "e"]) self.assertTrue(cm.exception.root_cause) - def test_left_join(self): - left_table = self.test_table.drop_columns(["d", "e"]) - right_table = self.test_table.drop_columns(["b", "c"]) - result_table = left_table.left_join(right_table, on=["a"], joins=["d", "e"]) - self.assertEqual(self.test_table.size, result_table.size) - def test_cross_join(self): left_table = self.test_table.drop_columns(cols=["e"]) right_table = self.test_table.where(["a % 2 > 0 && b % 3 == 1"]).drop_columns(cols=["b", "c", "d"]) diff --git a/qst/graphviz/src/main/java/io/deephaven/graphviz/LabelBuilder.java b/qst/graphviz/src/main/java/io/deephaven/graphviz/LabelBuilder.java index c06e19508e7..4522abbdc36 100644 --- a/qst/graphviz/src/main/java/io/deephaven/graphviz/LabelBuilder.java +++ b/qst/graphviz/src/main/java/io/deephaven/graphviz/LabelBuilder.java @@ -12,7 +12,6 @@ import io.deephaven.qst.table.InputTable; import io.deephaven.qst.table.Join; import io.deephaven.qst.table.JoinTable; -import io.deephaven.qst.table.LeftJoinTable; import io.deephaven.qst.table.NaturalJoinTable; import io.deephaven.qst.table.ReverseAsOfJoinTable; import io.deephaven.qst.table.SelectTable; @@ -92,11 +91,6 @@ public void visit(JoinTable joinTable) { join("join", joinTable); } - @Override - public void visit(LeftJoinTable leftJoinTable) { - join("leftJoin", leftJoinTable); - } - @Override public void visit(AsOfJoinTable aj) { join("aj", aj); diff --git a/qst/src/main/java/io/deephaven/qst/TableAdapterImpl.java b/qst/src/main/java/io/deephaven/qst/TableAdapterImpl.java index 1cdfbf9e1a1..a1bc7280e2a 100644 --- a/qst/src/main/java/io/deephaven/qst/TableAdapterImpl.java +++ b/qst/src/main/java/io/deephaven/qst/TableAdapterImpl.java @@ -10,7 +10,6 @@ import io.deephaven.qst.table.HeadTable; import io.deephaven.qst.table.InputTable; import io.deephaven.qst.table.JoinTable; -import io.deephaven.qst.table.LeftJoinTable; import io.deephaven.qst.table.MergeTable; import io.deephaven.qst.table.NaturalJoinTable; import io.deephaven.qst.table.NewTable; @@ -212,14 +211,6 @@ public void visit(JoinTable joinTable) { left.join(right, joinTable.matches(), joinTable.additions(), joinTable.reserveBits())); } - @Override - public void visit(LeftJoinTable leftJoinTable) { - final TOPS left = ops(leftJoinTable.left()); - final TABLE right = table(leftJoinTable.right()); - addOp(leftJoinTable, - left.exactJoin(right, leftJoinTable.matches(), leftJoinTable.additions())); - } - @Override public void visit(AsOfJoinTable aj) { final TOPS left = ops(aj.left()); diff --git a/qst/src/main/java/io/deephaven/qst/table/LeftJoinTable.java b/qst/src/main/java/io/deephaven/qst/table/LeftJoinTable.java deleted file mode 100644 index c8bcd61337c..00000000000 --- a/qst/src/main/java/io/deephaven/qst/table/LeftJoinTable.java +++ /dev/null @@ -1,29 +0,0 @@ -package io.deephaven.qst.table; - -import io.deephaven.annotations.NodeStyle; -import io.deephaven.api.TableOperations; -import org.immutables.value.Value.Immutable; - -import java.util.Collection; - -/** - * @see TableOperations#leftJoin(Object, Collection, Collection) - */ -@Immutable -@NodeStyle -public abstract class LeftJoinTable extends JoinBase { - - public static Builder builder() { - return ImmutableLeftJoinTable.builder(); - } - - @Override - public final V walk(V visitor) { - visitor.visit(this); - return visitor; - } - - public interface Builder extends Join.Builder { - - } -} diff --git a/qst/src/main/java/io/deephaven/qst/table/LinkDescriber.java b/qst/src/main/java/io/deephaven/qst/table/LinkDescriber.java index 0ae3d66aee9..46698f5ae52 100644 --- a/qst/src/main/java/io/deephaven/qst/table/LinkDescriber.java +++ b/qst/src/main/java/io/deephaven/qst/table/LinkDescriber.java @@ -61,11 +61,6 @@ public void visit(JoinTable joinTable) { join(joinTable); } - @Override - public void visit(LeftJoinTable leftJoinTable) { - join(leftJoinTable); - } - @Override public void visit(AsOfJoinTable aj) { join(aj); diff --git a/qst/src/main/java/io/deephaven/qst/table/ParentsVisitor.java b/qst/src/main/java/io/deephaven/qst/table/ParentsVisitor.java index 887607302b9..bea5a18b64c 100644 --- a/qst/src/main/java/io/deephaven/qst/table/ParentsVisitor.java +++ b/qst/src/main/java/io/deephaven/qst/table/ParentsVisitor.java @@ -209,11 +209,6 @@ public void visit(JoinTable joinTable) { out = Stream.of(joinTable.left(), joinTable.right()); } - @Override - public void visit(LeftJoinTable leftJoinTable) { - out = Stream.of(leftJoinTable.left(), leftJoinTable.right()); - } - @Override public void visit(AsOfJoinTable aj) { out = Stream.of(aj.left(), aj.right()); diff --git a/qst/src/main/java/io/deephaven/qst/table/TableBase.java b/qst/src/main/java/io/deephaven/qst/table/TableBase.java index 17ca034e611..e5e00b76b22 100644 --- a/qst/src/main/java/io/deephaven/qst/table/TableBase.java +++ b/qst/src/main/java/io/deephaven/qst/table/TableBase.java @@ -11,7 +11,6 @@ import io.deephaven.api.agg.Aggregation; import io.deephaven.api.filter.Filter; import io.deephaven.qst.TableCreationLogic; -import io.deephaven.qst.table.TableSchema.Visitor; import java.util.Arrays; import java.util.Collection; @@ -237,36 +236,6 @@ public final JoinTable join(TableSpec rightTable, String columnsToMatch, String return builder.build(); } - @Override - public final LeftJoinTable leftJoin(TableSpec rightTable, String columnsToMatch) { - LeftJoinTable.Builder builder = LeftJoinTable.builder().left(this).right(rightTable); - for (String match : split(columnsToMatch)) { - builder.addMatches(JoinMatch.parse(match)); - } - return builder.build(); - } - - @Override - public final LeftJoinTable leftJoin(TableSpec rightTable, String columnsToMatch, - String columnsToAdd) { - LeftJoinTable.Builder builder = LeftJoinTable.builder().left(this).right(rightTable); - for (String match : split(columnsToMatch)) { - builder.addMatches(JoinMatch.parse(match)); - } - for (String addition : split(columnsToAdd)) { - builder.addAdditions(JoinAddition.parse(addition)); - } - return builder.build(); - } - - @Override - public final LeftJoinTable leftJoin(TableSpec rightTable, - Collection columnsToMatch, - Collection columnsToAdd) { - return LeftJoinTable.builder().left(this).right(rightTable).addAllMatches(columnsToMatch) - .addAllAdditions(columnsToAdd).build(); - } - @Override public final AsOfJoinTable aj(TableSpec rightTable, String columnsToMatch) { AsOfJoinTable.Builder builder = AsOfJoinTable.builder().left(this).right(rightTable); diff --git a/qst/src/main/java/io/deephaven/qst/table/TableSpec.java b/qst/src/main/java/io/deephaven/qst/table/TableSpec.java index d4d3669480b..59bece4785f 100644 --- a/qst/src/main/java/io/deephaven/qst/table/TableSpec.java +++ b/qst/src/main/java/io/deephaven/qst/table/TableSpec.java @@ -127,8 +127,6 @@ interface Visitor { void visit(JoinTable joinTable); - void visit(LeftJoinTable leftJoinTable); - void visit(AsOfJoinTable aj); void visit(ReverseAsOfJoinTable raj); diff --git a/qst/src/main/java/io/deephaven/qst/table/TableVisitorGeneric.java b/qst/src/main/java/io/deephaven/qst/table/TableVisitorGeneric.java index 2b333a83172..bf379061b60 100644 --- a/qst/src/main/java/io/deephaven/qst/table/TableVisitorGeneric.java +++ b/qst/src/main/java/io/deephaven/qst/table/TableVisitorGeneric.java @@ -79,11 +79,6 @@ public void visit(JoinTable joinTable) { accept(joinTable); } - @Override - public void visit(LeftJoinTable leftJoinTable) { - accept(leftJoinTable); - } - @Override public void visit(AsOfJoinTable aj) { accept(aj); diff --git a/table-api/src/main/java/io/deephaven/api/JoinAddition.java b/table-api/src/main/java/io/deephaven/api/JoinAddition.java index 5ca75fe4a7d..00e1beb3d74 100644 --- a/table-api/src/main/java/io/deephaven/api/JoinAddition.java +++ b/table-api/src/main/java/io/deephaven/api/JoinAddition.java @@ -12,7 +12,6 @@ * @see TableOperations#join(Object, Collection, Collection, int) * @see TableOperations#naturalJoin(Object, Collection, Collection) * @see TableOperations#exactJoin(Object, Collection, Collection) - * @see TableOperations#leftJoin(Object, Collection, Collection) * @see TableOperations#aj(Object, Collection, Collection, AsOfJoinRule) * @see TableOperations#raj(Object, Collection, Collection, ReverseAsOfJoinRule) */ diff --git a/table-api/src/main/java/io/deephaven/api/JoinMatch.java b/table-api/src/main/java/io/deephaven/api/JoinMatch.java index 8003fb10c72..54fd2182e32 100644 --- a/table-api/src/main/java/io/deephaven/api/JoinMatch.java +++ b/table-api/src/main/java/io/deephaven/api/JoinMatch.java @@ -14,7 +14,6 @@ * @see TableOperations#join(Object, Collection, Collection, int) * @see TableOperations#naturalJoin(Object, Collection, Collection) * @see TableOperations#exactJoin(Object, Collection, Collection) - * @see TableOperations#leftJoin(Object, Collection, Collection) * @see TableOperations#aj(Object, Collection, Collection, AsOfJoinRule) * @see TableOperations#raj(Object, Collection, Collection, ReverseAsOfJoinRule) * @see TableOperations#whereIn(Object, Collection) diff --git a/table-api/src/main/java/io/deephaven/api/TableOperations.java b/table-api/src/main/java/io/deephaven/api/TableOperations.java index d50e0ff7b41..1a9bf49a1f0 100644 --- a/table-api/src/main/java/io/deephaven/api/TableOperations.java +++ b/table-api/src/main/java/io/deephaven/api/TableOperations.java @@ -257,65 +257,6 @@ TOPS exactJoin(TABLE rightTable, Collection columnsToMatch, // ------------------------------------------------------------------------------------------- - /** - * Perform a left-join with the {@code rightTable}. - * - *

- * Delegates to {@link #leftJoin(Object, Collection, Collection)}. - * - * @param rightTable The right side table on the join. - * @param columnsToMatch A comma separated list of match conditions ("leftColumn=rightColumn" or - * "columnFoundInBoth") - * @return the left-joined table - */ - TOPS leftJoin(TABLE rightTable, String columnsToMatch); - - /** - * Perform a left-join with the {@code rightTable}. - * - *

- * Delegates to {@link #leftJoin(Object, Collection, Collection)}. - * - * @param rightTable The right side table on the join. - * @param columnsToMatch A comma separated list of match conditions ("leftColumn=rightColumn" or - * "columnFoundInBoth") - * @param columnsToAdd A comma separated list with the columns from the right side that need to be added to the left - * side as a result of the match. - * @return the left-joined table - */ - TOPS leftJoin(TABLE rightTable, String columnsToMatch, String columnsToAdd); - - /** - * Perform a left-join with the {@code rightTable}. - * - *

- * Returns a table that has one column for each of {@code this} table's columns, and one column corresponding to - * each of the {@code rightTable} columns from {@code columnsToAdd} (or all the columns whose names don't overlap - * with the name of a column from the source table if {@code columnsToAdd} is empty). The new columns (those - * corresponding to the {@code rightTable}) contain an aggregation of all values from the left side that match the - * join criteria. Consequently the types of all right side columns not involved in a join criteria, is an array of - * the original column type. If the two tables have columns with matching names then the method will fail with an - * exception unless the columns with corresponding names are found in one of the matching criteria. - * - *

- * NOTE: leftJoin operation does not involve an actual data copy, or an in-memory table creation. In order to - * produce an actual in memory table you need to apply a select call on the join result. - * - * @param rightTable The right side table on the join. - * @param columnsToMatch The match pair conditions. - * @param columnsToAdd The columns from the right side that need to be added to the left side as a result of the - * match. - * @return a table that has one column for each original table's columns, and one column corresponding to each - * column listed in columnsToAdd. If {@code columnsToAdd.isEmpty()} one column corresponding to each column - * of the input table (right table) columns whose names don't overlap with the name of a column from the - * source table is added. The new columns (those corresponding to the input table) contain an aggregation of - * all values from the left side that match the join criteria. - */ - TOPS leftJoin(TABLE rightTable, Collection columnsToMatch, - Collection columnsToAdd); - - // ------------------------------------------------------------------------------------------- - /** * Perform a cross join with the {@code rightTable}. * diff --git a/table-api/src/main/java/io/deephaven/api/TableOperationsAdapter.java b/table-api/src/main/java/io/deephaven/api/TableOperationsAdapter.java index a02c3f3889b..25bab23f3ba 100644 --- a/table-api/src/main/java/io/deephaven/api/TableOperationsAdapter.java +++ b/table-api/src/main/java/io/deephaven/api/TableOperationsAdapter.java @@ -177,22 +177,6 @@ public final TOPS_1 exactJoin(TABLE_1 rightTable, return adapt(delegate.exactJoin(adapt(rightTable), columnsToMatch, columnsToAdd)); } - @Override - public final TOPS_1 leftJoin(TABLE_1 rightTable, String columnsToMatch) { - return adapt(delegate.leftJoin(adapt(rightTable), columnsToMatch)); - } - - @Override - public final TOPS_1 leftJoin(TABLE_1 rightTable, String columnsToMatch, String columnsToAdd) { - return adapt(delegate.leftJoin(adapt(rightTable), columnsToMatch, columnsToAdd)); - } - - @Override - public final TOPS_1 leftJoin(TABLE_1 rightTable, Collection columnsToMatch, - Collection columnsToAdd) { - return adapt(delegate.leftJoin(adapt(rightTable), columnsToMatch, columnsToAdd)); - } - @Override public final TOPS_1 join(TABLE_1 rightTable, String columnsToMatch) { return adapt(delegate.join(adapt(rightTable), columnsToMatch)); diff --git a/web/client-api/src/main/java/io/deephaven/web/client/api/JsTable.java b/web/client-api/src/main/java/io/deephaven/web/client/api/JsTable.java index fc7f02f0d46..51603b8ff01 100644 --- a/web/client-api/src/main/java/io/deephaven/web/client/api/JsTable.java +++ b/web/client-api/src/main/java/io/deephaven/web/client/api/JsTable.java @@ -9,7 +9,6 @@ import io.deephaven.javascript.proto.dhinternal.io.deephaven.proto.table_pb.AsOfJoinTablesRequest; import io.deephaven.javascript.proto.dhinternal.io.deephaven.proto.table_pb.CrossJoinTablesRequest; import io.deephaven.javascript.proto.dhinternal.io.deephaven.proto.table_pb.ExactJoinTablesRequest; -import io.deephaven.javascript.proto.dhinternal.io.deephaven.proto.table_pb.LeftJoinTablesRequest; import io.deephaven.javascript.proto.dhinternal.io.deephaven.proto.table_pb.NaturalJoinTablesRequest; import io.deephaven.javascript.proto.dhinternal.io.deephaven.proto.table_pb.RunChartDownsampleRequest; import io.deephaven.javascript.proto.dhinternal.io.deephaven.proto.table_pb.SelectDistinctRequest; @@ -824,8 +823,6 @@ public Promise join(Object joinType, JsTable rightTable, JsArray exactJoin(JsTable rightTable, JsArray columnsToM .then(state -> Promise.resolve(new JsTable(workerConnection, state))); } - @JsMethod - public Promise leftJoin(JsTable rightTable, JsArray columnsToMatch, - @JsOptional JsArray columnsToAdd) { - if (rightTable.workerConnection != workerConnection) { - throw new IllegalStateException( - "Table argument passed to join is not from the same worker as current table"); - } - return workerConnection.newState((c, state, metadata) -> { - LeftJoinTablesRequest request = new LeftJoinTablesRequest(); - request.setLeftId(state().getHandle().makeTableReference()); - request.setRightId(rightTable.state().getHandle().makeTableReference()); - request.setResultId(state.getHandle().makeTicket()); - request.setColumnsToMatchList(columnsToMatch); - request.setColumnsToAddList(columnsToAdd); - workerConnection.tableServiceClient().leftJoinTables(request, metadata, c::apply); - }, "leftJoin(" + rightTable + ", " + columnsToMatch + ", " + columnsToAdd + ")") - .refetch(this, workerConnection.metadata()) - .then(state -> Promise.resolve(new JsTable(workerConnection, state))); - } - @JsMethod public Promise naturalJoin(JsTable rightTable, JsArray columnsToMatch, @JsOptional JsArray columnsToAdd) {