repo stringlengths 7 58 | path stringlengths 12 218 | func_name stringlengths 3 140 | original_string stringlengths 73 34.1k | language stringclasses 1
value | code stringlengths 73 34.1k | code_tokens list | docstring stringlengths 3 16k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 105 339 | partition stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
VoltDB/voltdb | src/frontend/org/voltdb/planner/PlanAssembler.java | PlanAssembler.fixDistributedApproxCountDistinct | private static void fixDistributedApproxCountDistinct(
AggregatePlanNode distNode,
AggregatePlanNode coordNode) {
assert (distNode != null);
assert (coordNode != null);
// Patch up any APPROX_COUNT_DISTINCT on the distributed node.
List<ExpressionType> distAggTy... | java | private static void fixDistributedApproxCountDistinct(
AggregatePlanNode distNode,
AggregatePlanNode coordNode) {
assert (distNode != null);
assert (coordNode != null);
// Patch up any APPROX_COUNT_DISTINCT on the distributed node.
List<ExpressionType> distAggTy... | [
"private",
"static",
"void",
"fixDistributedApproxCountDistinct",
"(",
"AggregatePlanNode",
"distNode",
",",
"AggregatePlanNode",
"coordNode",
")",
"{",
"assert",
"(",
"distNode",
"!=",
"null",
")",
";",
"assert",
"(",
"coordNode",
"!=",
"null",
")",
";",
"// Patc... | This function is called once it's been determined that we can push down
an aggregation plan node.
If an APPROX_COUNT_DISTINCT aggregate is distributed, then we need to
convert the distributed aggregate function to VALS_TO_HYPERLOGLOG,
and the coordinating aggregate function to HYPERLOGLOGS_TO_CARD.
@param distNode ... | [
"This",
"function",
"is",
"called",
"once",
"it",
"s",
"been",
"determined",
"that",
"we",
"can",
"push",
"down",
"an",
"aggregation",
"plan",
"node",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/PlanAssembler.java#L3004-L3032 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/PlanAssembler.java | PlanAssembler.checkLimitPushDownViability | protected AbstractPlanNode checkLimitPushDownViability(
AbstractPlanNode root) {
AbstractPlanNode receiveNode = root;
List<ParsedColInfo> orderBys = m_parsedSelect.orderByColumns();
boolean orderByCoversAllGroupBy = m_parsedSelect.groupByIsAnOrderByPermutation();
while ( ! (... | java | protected AbstractPlanNode checkLimitPushDownViability(
AbstractPlanNode root) {
AbstractPlanNode receiveNode = root;
List<ParsedColInfo> orderBys = m_parsedSelect.orderByColumns();
boolean orderByCoversAllGroupBy = m_parsedSelect.groupByIsAnOrderByPermutation();
while ( ! (... | [
"protected",
"AbstractPlanNode",
"checkLimitPushDownViability",
"(",
"AbstractPlanNode",
"root",
")",
"{",
"AbstractPlanNode",
"receiveNode",
"=",
"root",
";",
"List",
"<",
"ParsedColInfo",
">",
"orderBys",
"=",
"m_parsedSelect",
".",
"orderByColumns",
"(",
")",
";",
... | Check if we can push the limit node down.
Return a mid-plan send node, if one exists and can host a
distributed limit node.
There is guaranteed to be at most a single receive/send pair.
Abort the search if a node that a "limit" can't be pushed past
is found before its receive node.
Can only push past:
* coordinatingA... | [
"Check",
"if",
"we",
"can",
"push",
"the",
"limit",
"node",
"down",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/PlanAssembler.java#L3166-L3204 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/PlanAssembler.java | PlanAssembler.getIndexedColumnSetForTable | private static Set<String> getIndexedColumnSetForTable(Table table) {
HashSet<String> columns = new HashSet<>();
for (Index index : table.getIndexes()) {
for (ColumnRef colRef : index.getColumns()) {
columns.add(colRef.getColumn().getTypeName());
}
}
... | java | private static Set<String> getIndexedColumnSetForTable(Table table) {
HashSet<String> columns = new HashSet<>();
for (Index index : table.getIndexes()) {
for (ColumnRef colRef : index.getColumns()) {
columns.add(colRef.getColumn().getTypeName());
}
}
... | [
"private",
"static",
"Set",
"<",
"String",
">",
"getIndexedColumnSetForTable",
"(",
"Table",
"table",
")",
"{",
"HashSet",
"<",
"String",
">",
"columns",
"=",
"new",
"HashSet",
"<>",
"(",
")",
";",
"for",
"(",
"Index",
"index",
":",
"table",
".",
"getInd... | Get the unique set of names of all columns that are part of an index on
the given table.
@param table
The table to build the list of index-affected columns with.
@return The set of column names affected by indexes with duplicates
removed. | [
"Get",
"the",
"unique",
"set",
"of",
"names",
"of",
"all",
"columns",
"that",
"are",
"part",
"of",
"an",
"index",
"on",
"the",
"given",
"table",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/PlanAssembler.java#L3343-L3353 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/PlanAssembler.java | PlanAssembler.isNullRejecting | private static boolean isNullRejecting(Collection<String> tableAliases,
List<AbstractExpression> exprs) {
for (AbstractExpression expr : exprs) {
for (String tableAlias : tableAliases) {
if (ExpressionUtil.isNullRejectingExpression(expr, tableAlias)) {
... | java | private static boolean isNullRejecting(Collection<String> tableAliases,
List<AbstractExpression> exprs) {
for (AbstractExpression expr : exprs) {
for (String tableAlias : tableAliases) {
if (ExpressionUtil.isNullRejectingExpression(expr, tableAlias)) {
... | [
"private",
"static",
"boolean",
"isNullRejecting",
"(",
"Collection",
"<",
"String",
">",
"tableAliases",
",",
"List",
"<",
"AbstractExpression",
">",
"exprs",
")",
"{",
"for",
"(",
"AbstractExpression",
"expr",
":",
"exprs",
")",
"{",
"for",
"(",
"String",
... | Verify if an expression from the input list is NULL-rejecting
for any of the tables from the list
@param tableAliases list of tables
@param exprs list of expressions
@return TRUE if there is a NULL-rejecting expression | [
"Verify",
"if",
"an",
"expression",
"from",
"the",
"input",
"list",
"is",
"NULL",
"-",
"rejecting",
"for",
"any",
"of",
"the",
"tables",
"from",
"the",
"list"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/PlanAssembler.java#L3490-L3501 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/SubPlanAssembler.java | SubPlanAssembler.determineIndexOrdering | private int determineIndexOrdering(StmtTableScan tableScan,
int keyComponentCount,
List<AbstractExpression> indexedExprs,
List<ColumnRef> indexedColRefs,
AccessPath retval,
int[] orderSpoilers,
List<AbstractExpression> bindingsForOrder)
{
... | java | private int determineIndexOrdering(StmtTableScan tableScan,
int keyComponentCount,
List<AbstractExpression> indexedExprs,
List<ColumnRef> indexedColRefs,
AccessPath retval,
int[] orderSpoilers,
List<AbstractExpression> bindingsForOrder)
{
... | [
"private",
"int",
"determineIndexOrdering",
"(",
"StmtTableScan",
"tableScan",
",",
"int",
"keyComponentCount",
",",
"List",
"<",
"AbstractExpression",
">",
"indexedExprs",
",",
"List",
"<",
"ColumnRef",
">",
"indexedColRefs",
",",
"AccessPath",
"retval",
",",
"int"... | Determine if an index, which is in the AccessPath argument
retval, can satisfy a parsed select statement's order by or
window function ordering requirements.
@param table only used here to validate base table names of ORDER BY columns' .
@param bindingsForOrder restrictions on parameter settings that ar... | [
"Determine",
"if",
"an",
"index",
"which",
"is",
"in",
"the",
"AccessPath",
"argument",
"retval",
"can",
"satisfy",
"a",
"parsed",
"select",
"statement",
"s",
"order",
"by",
"or",
"window",
"function",
"ordering",
"requirements",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/SubPlanAssembler.java#L1619-L1719 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/SubPlanAssembler.java | SubPlanAssembler.findBindingsForOneIndexedExpression | private static List<AbstractExpression>
findBindingsForOneIndexedExpression(ExpressionOrColumn nextStatementEOC,
ExpressionOrColumn indexEntry) {
assert(nextStatementEOC.m_expr != null);
AbstractExpression nextStatementExpr = nextStatementEOC.m_expr;
... | java | private static List<AbstractExpression>
findBindingsForOneIndexedExpression(ExpressionOrColumn nextStatementEOC,
ExpressionOrColumn indexEntry) {
assert(nextStatementEOC.m_expr != null);
AbstractExpression nextStatementExpr = nextStatementEOC.m_expr;
... | [
"private",
"static",
"List",
"<",
"AbstractExpression",
">",
"findBindingsForOneIndexedExpression",
"(",
"ExpressionOrColumn",
"nextStatementEOC",
",",
"ExpressionOrColumn",
"indexEntry",
")",
"{",
"assert",
"(",
"nextStatementEOC",
".",
"m_expr",
"!=",
"null",
")",
";"... | Match the indexEntry, which is from an index, with
a statement expression or column. The nextStatementEOC
must be an expression, not a column reference.
@param nextStatementEOC The expression or column in the SQL statement.
@param indexEntry The expression or column in the index.
@return A list of bindings for this m... | [
"Match",
"the",
"indexEntry",
"which",
"is",
"from",
"an",
"index",
"with",
"a",
"statement",
"expression",
"or",
"column",
".",
"The",
"nextStatementEOC",
"must",
"be",
"an",
"expression",
"not",
"a",
"column",
"reference",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/SubPlanAssembler.java#L1733-L1754 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/SubPlanAssembler.java | SubPlanAssembler.removeExactMatchCoveredExpressions | private static boolean removeExactMatchCoveredExpressions(
AbstractExpression coveringExpr, List<AbstractExpression> exprsToCover) {
boolean hasMatch = false;
Iterator<AbstractExpression> iter = exprsToCover.iterator();
while(iter.hasNext()) {
AbstractExpression exprToCo... | java | private static boolean removeExactMatchCoveredExpressions(
AbstractExpression coveringExpr, List<AbstractExpression> exprsToCover) {
boolean hasMatch = false;
Iterator<AbstractExpression> iter = exprsToCover.iterator();
while(iter.hasNext()) {
AbstractExpression exprToCo... | [
"private",
"static",
"boolean",
"removeExactMatchCoveredExpressions",
"(",
"AbstractExpression",
"coveringExpr",
",",
"List",
"<",
"AbstractExpression",
">",
"exprsToCover",
")",
"{",
"boolean",
"hasMatch",
"=",
"false",
";",
"Iterator",
"<",
"AbstractExpression",
">",
... | Loop over the expressions to cover to find ones that exactly match the covering expression
and remove them from the original list. Returns true if there is at least one match. False otherwise.
@param coveringExpr
@param exprsToCover
@return true is the covering expression exactly matches to one or more expressions to c... | [
"Loop",
"over",
"the",
"expressions",
"to",
"cover",
"to",
"find",
"ones",
"that",
"exactly",
"match",
"the",
"covering",
"expression",
"and",
"remove",
"them",
"from",
"the",
"original",
"list",
".",
"Returns",
"true",
"if",
"there",
"is",
"at",
"least",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/SubPlanAssembler.java#L2020-L2034 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/SubPlanAssembler.java | SubPlanAssembler.removeNotNullCoveredExpressions | private static List<AbstractExpression> removeNotNullCoveredExpressions(StmtTableScan tableScan, List<AbstractExpression> coveringExprs, List<AbstractExpression> exprsToCover) {
// Collect all TVEs from NULL-rejecting covering expressions
Set<TupleValueExpression> coveringTves = new HashSet<>();
... | java | private static List<AbstractExpression> removeNotNullCoveredExpressions(StmtTableScan tableScan, List<AbstractExpression> coveringExprs, List<AbstractExpression> exprsToCover) {
// Collect all TVEs from NULL-rejecting covering expressions
Set<TupleValueExpression> coveringTves = new HashSet<>();
... | [
"private",
"static",
"List",
"<",
"AbstractExpression",
">",
"removeNotNullCoveredExpressions",
"(",
"StmtTableScan",
"tableScan",
",",
"List",
"<",
"AbstractExpression",
">",
"coveringExprs",
",",
"List",
"<",
"AbstractExpression",
">",
"exprsToCover",
")",
"{",
"// ... | Remove NOT NULL expressions that are covered by the NULL-rejecting expressions. For example,
'COL IS NOT NULL' is covered by the 'COL > 0' NULL-rejecting comparison expression.
@param tableScan
@param coveringExprs
@param exprsToCover
@return List<AbstractExpression> | [
"Remove",
"NOT",
"NULL",
"expressions",
"that",
"are",
"covered",
"by",
"the",
"NULL",
"-",
"rejecting",
"expressions",
".",
"For",
"example",
"COL",
"IS",
"NOT",
"NULL",
"is",
"covered",
"by",
"the",
"COL",
">",
"0",
"NULL",
"-",
"rejecting",
"comparison"... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/SubPlanAssembler.java#L2045-L2070 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/SubPlanAssembler.java | SubPlanAssembler.addSendReceivePair | protected static AbstractPlanNode addSendReceivePair(AbstractPlanNode scanNode) {
SendPlanNode sendNode = new SendPlanNode();
sendNode.addAndLinkChild(scanNode);
ReceivePlanNode recvNode = new ReceivePlanNode();
recvNode.addAndLinkChild(sendNode);
return recvNode;
} | java | protected static AbstractPlanNode addSendReceivePair(AbstractPlanNode scanNode) {
SendPlanNode sendNode = new SendPlanNode();
sendNode.addAndLinkChild(scanNode);
ReceivePlanNode recvNode = new ReceivePlanNode();
recvNode.addAndLinkChild(sendNode);
return recvNode;
} | [
"protected",
"static",
"AbstractPlanNode",
"addSendReceivePair",
"(",
"AbstractPlanNode",
"scanNode",
")",
"{",
"SendPlanNode",
"sendNode",
"=",
"new",
"SendPlanNode",
"(",
")",
";",
"sendNode",
".",
"addAndLinkChild",
"(",
"scanNode",
")",
";",
"ReceivePlanNode",
"... | Insert a send receive pair above the supplied scanNode.
@param scanNode that needs to be distributed
@return return the newly created receive node (which is linked to the new sends) | [
"Insert",
"a",
"send",
"receive",
"pair",
"above",
"the",
"supplied",
"scanNode",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/SubPlanAssembler.java#L2133-L2141 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/SubPlanAssembler.java | SubPlanAssembler.getAccessPlanForTable | protected static AbstractPlanNode getAccessPlanForTable(JoinNode tableNode) {
StmtTableScan tableScan = tableNode.getTableScan();
// Access path to access the data in the table (index/scan/etc).
AccessPath path = tableNode.m_currentAccessPath;
assert(path != null);
// if no inde... | java | protected static AbstractPlanNode getAccessPlanForTable(JoinNode tableNode) {
StmtTableScan tableScan = tableNode.getTableScan();
// Access path to access the data in the table (index/scan/etc).
AccessPath path = tableNode.m_currentAccessPath;
assert(path != null);
// if no inde... | [
"protected",
"static",
"AbstractPlanNode",
"getAccessPlanForTable",
"(",
"JoinNode",
"tableNode",
")",
"{",
"StmtTableScan",
"tableScan",
"=",
"tableNode",
".",
"getTableScan",
"(",
")",
";",
"// Access path to access the data in the table (index/scan/etc).",
"AccessPath",
"p... | Given an access path, build the single-site or distributed plan that will
assess the data from the table according to the path.
@param table The table to get data from.
@return The root of a plan graph to get the data. | [
"Given",
"an",
"access",
"path",
"build",
"the",
"single",
"-",
"site",
"or",
"distributed",
"plan",
"that",
"will",
"assess",
"the",
"data",
"from",
"the",
"table",
"according",
"to",
"the",
"path",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/SubPlanAssembler.java#L2150-L2161 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/SubPlanAssembler.java | SubPlanAssembler.getIndexAccessPlanForTable | private static AbstractPlanNode getIndexAccessPlanForTable(
StmtTableScan tableScan, AccessPath path) {
// now assume this will be an index scan and get the relevant index
Index index = path.index;
IndexScanPlanNode scanNode = new IndexScanPlanNode(tableScan, index);
Abstract... | java | private static AbstractPlanNode getIndexAccessPlanForTable(
StmtTableScan tableScan, AccessPath path) {
// now assume this will be an index scan and get the relevant index
Index index = path.index;
IndexScanPlanNode scanNode = new IndexScanPlanNode(tableScan, index);
Abstract... | [
"private",
"static",
"AbstractPlanNode",
"getIndexAccessPlanForTable",
"(",
"StmtTableScan",
"tableScan",
",",
"AccessPath",
"path",
")",
"{",
"// now assume this will be an index scan and get the relevant index",
"Index",
"index",
"=",
"path",
".",
"index",
";",
"IndexScanPl... | Get an index scan access plan for a table.
@param tableAliasIndex The table to get data from.
@param path The access path to access the data in the table (index/scan/etc).
@return An index scan plan node OR,
in one edge case, an NLIJ of a MaterializedScan and an index scan plan node. | [
"Get",
"an",
"index",
"scan",
"access",
"plan",
"for",
"a",
"table",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/SubPlanAssembler.java#L2189-L2261 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/SubPlanAssembler.java | SubPlanAssembler.injectIndexedJoinWithMaterializedScan | private static AbstractPlanNode injectIndexedJoinWithMaterializedScan(
AbstractExpression listElements, IndexScanPlanNode scanNode) {
MaterializedScanPlanNode matScan = new MaterializedScanPlanNode();
assert(listElements instanceof VectorValueExpression || listElements instanceof ParameterVa... | java | private static AbstractPlanNode injectIndexedJoinWithMaterializedScan(
AbstractExpression listElements, IndexScanPlanNode scanNode) {
MaterializedScanPlanNode matScan = new MaterializedScanPlanNode();
assert(listElements instanceof VectorValueExpression || listElements instanceof ParameterVa... | [
"private",
"static",
"AbstractPlanNode",
"injectIndexedJoinWithMaterializedScan",
"(",
"AbstractExpression",
"listElements",
",",
"IndexScanPlanNode",
"scanNode",
")",
"{",
"MaterializedScanPlanNode",
"matScan",
"=",
"new",
"MaterializedScanPlanNode",
"(",
")",
";",
"assert",... | Generate a plan for an IN-LIST-driven index scan | [
"Generate",
"a",
"plan",
"for",
"an",
"IN",
"-",
"LIST",
"-",
"driven",
"index",
"scan"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/SubPlanAssembler.java#L2265-L2279 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/SubPlanAssembler.java | SubPlanAssembler.replaceInListFilterWithEqualityFilter | private static void replaceInListFilterWithEqualityFilter(List<AbstractExpression> endExprs,
AbstractExpression inListRhs,
AbstractExpression equalityRhs)
{
for (AbstractExpression comparator : endE... | java | private static void replaceInListFilterWithEqualityFilter(List<AbstractExpression> endExprs,
AbstractExpression inListRhs,
AbstractExpression equalityRhs)
{
for (AbstractExpression comparator : endE... | [
"private",
"static",
"void",
"replaceInListFilterWithEqualityFilter",
"(",
"List",
"<",
"AbstractExpression",
">",
"endExprs",
",",
"AbstractExpression",
"inListRhs",
",",
"AbstractExpression",
"equalityRhs",
")",
"{",
"for",
"(",
"AbstractExpression",
"comparator",
":",
... | with an equality filter referencing the second given rhs. | [
"with",
"an",
"equality",
"filter",
"referencing",
"the",
"second",
"given",
"rhs",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/SubPlanAssembler.java#L2284-L2300 | train |
VoltDB/voltdb | examples/callcenter/client/callcenter/CallSimulator.java | CallSimulator.makeRandomEvent | CallEvent[] makeRandomEvent() {
long callId = ++lastCallIdUsed;
// get agentid
Integer agentId = agentsAvailable.poll();
if (agentId == null) {
return null;
}
// get phone number
Long phoneNo = phoneNumbersAvailable.poll();
assert(phoneNo != ... | java | CallEvent[] makeRandomEvent() {
long callId = ++lastCallIdUsed;
// get agentid
Integer agentId = agentsAvailable.poll();
if (agentId == null) {
return null;
}
// get phone number
Long phoneNo = phoneNumbersAvailable.poll();
assert(phoneNo != ... | [
"CallEvent",
"[",
"]",
"makeRandomEvent",
"(",
")",
"{",
"long",
"callId",
"=",
"++",
"lastCallIdUsed",
";",
"// get agentid",
"Integer",
"agentId",
"=",
"agentsAvailable",
".",
"poll",
"(",
")",
";",
"if",
"(",
"agentId",
"==",
"null",
")",
"{",
"return",... | Generate a random call event with a duration.
Reserves agent and phone number from the pool. | [
"Generate",
"a",
"random",
"call",
"event",
"with",
"a",
"duration",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/examples/callcenter/client/callcenter/CallSimulator.java#L86-L123 | train |
VoltDB/voltdb | examples/callcenter/client/callcenter/CallSimulator.java | CallSimulator.next | @Override
public CallEvent next(long systemCurrentTimeMillis) {
// check for time passing
if (systemCurrentTimeMillis > currentSystemMilliTimestamp) {
// build a target for this 1ms window
long eventBacklog = targetEventsThisMillisecond - eventsSoFarThisMillisecond;
... | java | @Override
public CallEvent next(long systemCurrentTimeMillis) {
// check for time passing
if (systemCurrentTimeMillis > currentSystemMilliTimestamp) {
// build a target for this 1ms window
long eventBacklog = targetEventsThisMillisecond - eventsSoFarThisMillisecond;
... | [
"@",
"Override",
"public",
"CallEvent",
"next",
"(",
"long",
"systemCurrentTimeMillis",
")",
"{",
"// check for time passing",
"if",
"(",
"systemCurrentTimeMillis",
">",
"currentSystemMilliTimestamp",
")",
"{",
"// build a target for this 1ms window",
"long",
"eventBacklog",
... | Return the next call event that is safe for delivery or null
if there are no safe objects to deliver.
Null response could mean empty, or could mean all objects
are scheduled for the future.
@param systemCurrentTimeMillis The current time.
@return CallEvent | [
"Return",
"the",
"next",
"call",
"event",
"that",
"is",
"safe",
"for",
"delivery",
"or",
"null",
"if",
"there",
"are",
"no",
"safe",
"objects",
"to",
"deliver",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/examples/callcenter/client/callcenter/CallSimulator.java#L135-L188 | train |
VoltDB/voltdb | examples/callcenter/client/callcenter/CallSimulator.java | CallSimulator.validate | private void validate() {
long delayedEventCount = delayedEvents.size();
long outstandingAgents = config.agents - agentsAvailable.size();
long outstandingPhones = config.numbers - phoneNumbersAvailable.size();
if (outstandingAgents != outstandingPhones) {
throw new RuntimeE... | java | private void validate() {
long delayedEventCount = delayedEvents.size();
long outstandingAgents = config.agents - agentsAvailable.size();
long outstandingPhones = config.numbers - phoneNumbersAvailable.size();
if (outstandingAgents != outstandingPhones) {
throw new RuntimeE... | [
"private",
"void",
"validate",
"(",
")",
"{",
"long",
"delayedEventCount",
"=",
"delayedEvents",
".",
"size",
"(",
")",
";",
"long",
"outstandingAgents",
"=",
"config",
".",
"agents",
"-",
"agentsAvailable",
".",
"size",
"(",
")",
";",
"long",
"outstandingPh... | Smoke check on validity of data structures.
This was useful while getting the code right for this class,
but it doesn't do much now, unless the code needs changes. | [
"Smoke",
"check",
"on",
"validity",
"of",
"data",
"structures",
".",
"This",
"was",
"useful",
"while",
"getting",
"the",
"code",
"right",
"for",
"this",
"class",
"but",
"it",
"doesn",
"t",
"do",
"much",
"now",
"unless",
"the",
"code",
"needs",
"changes",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/examples/callcenter/client/callcenter/CallSimulator.java#L219-L235 | train |
VoltDB/voltdb | examples/callcenter/client/callcenter/CallSimulator.java | CallSimulator.printSummary | void printSummary() {
System.out.printf("There are %d agents outstanding and %d phones. %d entries waiting to go.\n",
agentsAvailable.size(), phoneNumbersAvailable.size(), delayedEvents.size());
} | java | void printSummary() {
System.out.printf("There are %d agents outstanding and %d phones. %d entries waiting to go.\n",
agentsAvailable.size(), phoneNumbersAvailable.size(), delayedEvents.size());
} | [
"void",
"printSummary",
"(",
")",
"{",
"System",
".",
"out",
".",
"printf",
"(",
"\"There are %d agents outstanding and %d phones. %d entries waiting to go.\\n\"",
",",
"agentsAvailable",
".",
"size",
"(",
")",
",",
"phoneNumbersAvailable",
".",
"size",
"(",
")",
",",... | Debug statement to help users verify there are no lost or delayed events. | [
"Debug",
"statement",
"to",
"help",
"users",
"verify",
"there",
"are",
"no",
"lost",
"or",
"delayed",
"events",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/examples/callcenter/client/callcenter/CallSimulator.java#L240-L243 | train |
VoltDB/voltdb | third_party/java/src/org/apache/commons_voltpatches/cli/DefaultParser.java | DefaultParser.isNegativeNumber | private boolean isNegativeNumber(String token)
{
try
{
Double.parseDouble(token);
return true;
}
catch (NumberFormatException e)
{
return false;
}
} | java | private boolean isNegativeNumber(String token)
{
try
{
Double.parseDouble(token);
return true;
}
catch (NumberFormatException e)
{
return false;
}
} | [
"private",
"boolean",
"isNegativeNumber",
"(",
"String",
"token",
")",
"{",
"try",
"{",
"Double",
".",
"parseDouble",
"(",
"token",
")",
";",
"return",
"true",
";",
"}",
"catch",
"(",
"NumberFormatException",
"e",
")",
"{",
"return",
"false",
";",
"}",
"... | Check if the token is a negative number.
@param token | [
"Check",
"if",
"the",
"token",
"is",
"a",
"negative",
"number",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/commons_voltpatches/cli/DefaultParser.java#L271-L282 | train |
VoltDB/voltdb | third_party/java/src/org/apache/commons_voltpatches/cli/DefaultParser.java | DefaultParser.isLongOption | private boolean isLongOption(String token)
{
if (!token.startsWith("-") || token.length() == 1)
{
return false;
}
int pos = token.indexOf("=");
String t = pos == -1 ? token : token.substring(0, pos);
if (!options.getMatchingOptions(t).isEmpty())
... | java | private boolean isLongOption(String token)
{
if (!token.startsWith("-") || token.length() == 1)
{
return false;
}
int pos = token.indexOf("=");
String t = pos == -1 ? token : token.substring(0, pos);
if (!options.getMatchingOptions(t).isEmpty())
... | [
"private",
"boolean",
"isLongOption",
"(",
"String",
"token",
")",
"{",
"if",
"(",
"!",
"token",
".",
"startsWith",
"(",
"\"-\"",
")",
"||",
"token",
".",
"length",
"(",
")",
"==",
"1",
")",
"{",
"return",
"false",
";",
"}",
"int",
"pos",
"=",
"tok... | Tells if the token looks like a long option.
@param token | [
"Tells",
"if",
"the",
"token",
"looks",
"like",
"a",
"long",
"option",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/commons_voltpatches/cli/DefaultParser.java#L310-L332 | train |
VoltDB/voltdb | third_party/java/src/org/apache/commons_voltpatches/cli/DefaultParser.java | DefaultParser.handleUnknownToken | private void handleUnknownToken(String token) throws ParseException
{
if (token.startsWith("-") && token.length() > 1 && !stopAtNonOption)
{
throw new UnrecognizedOptionException("Unrecognized option: " + token, token);
}
cmd.addArg(token);
if (stopAtNonOption)
... | java | private void handleUnknownToken(String token) throws ParseException
{
if (token.startsWith("-") && token.length() > 1 && !stopAtNonOption)
{
throw new UnrecognizedOptionException("Unrecognized option: " + token, token);
}
cmd.addArg(token);
if (stopAtNonOption)
... | [
"private",
"void",
"handleUnknownToken",
"(",
"String",
"token",
")",
"throws",
"ParseException",
"{",
"if",
"(",
"token",
".",
"startsWith",
"(",
"\"-\"",
")",
"&&",
"token",
".",
"length",
"(",
")",
">",
"1",
"&&",
"!",
"stopAtNonOption",
")",
"{",
"th... | Handles an unknown token. If the token starts with a dash an
UnrecognizedOptionException is thrown. Otherwise the token is added
to the arguments of the command line. If the stopAtNonOption flag
is set, this stops the parsing and the remaining tokens are added
as-is in the arguments of the command line.
@param token t... | [
"Handles",
"an",
"unknown",
"token",
".",
"If",
"the",
"token",
"starts",
"with",
"a",
"dash",
"an",
"UnrecognizedOptionException",
"is",
"thrown",
".",
"Otherwise",
"the",
"token",
"is",
"added",
"to",
"the",
"arguments",
"of",
"the",
"command",
"line",
"."... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/commons_voltpatches/cli/DefaultParser.java#L343-L355 | train |
VoltDB/voltdb | src/frontend/org/voltdb/SQLStmt.java | SQLStmt.getText | public String getText() {
if (sqlTextStr == null) {
sqlTextStr = new String(sqlText, Constants.UTF8ENCODING);
}
return sqlTextStr;
} | java | public String getText() {
if (sqlTextStr == null) {
sqlTextStr = new String(sqlText, Constants.UTF8ENCODING);
}
return sqlTextStr;
} | [
"public",
"String",
"getText",
"(",
")",
"{",
"if",
"(",
"sqlTextStr",
"==",
"null",
")",
"{",
"sqlTextStr",
"=",
"new",
"String",
"(",
"sqlText",
",",
"Constants",
".",
"UTF8ENCODING",
")",
";",
"}",
"return",
"sqlTextStr",
";",
"}"
] | Get the text of the SQL statement represented.
@return String containing the text of the SQL statement represented. | [
"Get",
"the",
"text",
"of",
"the",
"SQL",
"statement",
"represented",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/SQLStmt.java#L201-L206 | train |
VoltDB/voltdb | src/frontend/org/voltdb/SQLStmt.java | SQLStmt.canonicalizeStmt | public static String canonicalizeStmt(String stmtStr) {
// Cleanup whitespace newlines and adding semicolon for catalog compatibility
stmtStr = stmtStr.replaceAll("\n", " ");
stmtStr = stmtStr.trim();
if (!stmtStr.endsWith(";")) {
stmtStr += ";";
}
return stm... | java | public static String canonicalizeStmt(String stmtStr) {
// Cleanup whitespace newlines and adding semicolon for catalog compatibility
stmtStr = stmtStr.replaceAll("\n", " ");
stmtStr = stmtStr.trim();
if (!stmtStr.endsWith(";")) {
stmtStr += ";";
}
return stm... | [
"public",
"static",
"String",
"canonicalizeStmt",
"(",
"String",
"stmtStr",
")",
"{",
"// Cleanup whitespace newlines and adding semicolon for catalog compatibility",
"stmtStr",
"=",
"stmtStr",
".",
"replaceAll",
"(",
"\"\\n\"",
",",
"\" \"",
")",
";",
"stmtStr",
"=",
"... | use the same statement to compute crc. | [
"use",
"the",
"same",
"statement",
"to",
"compute",
"crc",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/SQLStmt.java#L229-L238 | train |
VoltDB/voltdb | third_party/java/src/com/google_voltpatches/common/net/PercentEscaper.java | PercentEscaper.createSafeOctets | private static boolean[] createSafeOctets(String safeChars) {
int maxChar = -1;
char[] safeCharArray = safeChars.toCharArray();
for (char c : safeCharArray) {
maxChar = Math.max(c, maxChar);
}
boolean[] octets = new boolean[maxChar + 1];
for (char c : safeCharArray) {
octets[c] = tru... | java | private static boolean[] createSafeOctets(String safeChars) {
int maxChar = -1;
char[] safeCharArray = safeChars.toCharArray();
for (char c : safeCharArray) {
maxChar = Math.max(c, maxChar);
}
boolean[] octets = new boolean[maxChar + 1];
for (char c : safeCharArray) {
octets[c] = tru... | [
"private",
"static",
"boolean",
"[",
"]",
"createSafeOctets",
"(",
"String",
"safeChars",
")",
"{",
"int",
"maxChar",
"=",
"-",
"1",
";",
"char",
"[",
"]",
"safeCharArray",
"=",
"safeChars",
".",
"toCharArray",
"(",
")",
";",
"for",
"(",
"char",
"c",
"... | Creates a boolean array with entries corresponding to the character values specified in
safeChars set to true. The array is as small as is required to hold the given character
information. | [
"Creates",
"a",
"boolean",
"array",
"with",
"entries",
"corresponding",
"to",
"the",
"character",
"values",
"specified",
"in",
"safeChars",
"set",
"to",
"true",
".",
"The",
"array",
"is",
"as",
"small",
"as",
"is",
"required",
"to",
"hold",
"the",
"given",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/com/google_voltpatches/common/net/PercentEscaper.java#L111-L122 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ExpressionColumn.java | ExpressionColumn.getTableName | String getTableName() {
if (opType == OpTypes.MULTICOLUMN) {
return tableName;
}
if (opType == OpTypes.COLUMN) {
if (rangeVariable == null) {
return tableName;
}
return rangeVariable.getTable().getName().name;
}
ret... | java | String getTableName() {
if (opType == OpTypes.MULTICOLUMN) {
return tableName;
}
if (opType == OpTypes.COLUMN) {
if (rangeVariable == null) {
return tableName;
}
return rangeVariable.getTable().getName().name;
}
ret... | [
"String",
"getTableName",
"(",
")",
"{",
"if",
"(",
"opType",
"==",
"OpTypes",
".",
"MULTICOLUMN",
")",
"{",
"return",
"tableName",
";",
"}",
"if",
"(",
"opType",
"==",
"OpTypes",
".",
"COLUMN",
")",
"{",
"if",
"(",
"rangeVariable",
"==",
"null",
")",
... | Returns the table name for a column expression as a string
@return table name | [
"Returns",
"the",
"table",
"name",
"for",
"a",
"column",
"expression",
"as",
"a",
"string"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ExpressionColumn.java#L770-L782 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ExpressionColumn.java | ExpressionColumn.voltAnnotateColumnXML | VoltXMLElement voltAnnotateColumnXML(VoltXMLElement exp) {
if (tableName != null) {
if (rangeVariable != null && rangeVariable.rangeTable != null &&
rangeVariable.tableAlias != null &&
rangeVariable.rangeTable.tableType == TableBase.SYSTEM_SUBQUERY) {
... | java | VoltXMLElement voltAnnotateColumnXML(VoltXMLElement exp) {
if (tableName != null) {
if (rangeVariable != null && rangeVariable.rangeTable != null &&
rangeVariable.tableAlias != null &&
rangeVariable.rangeTable.tableType == TableBase.SYSTEM_SUBQUERY) {
... | [
"VoltXMLElement",
"voltAnnotateColumnXML",
"(",
"VoltXMLElement",
"exp",
")",
"{",
"if",
"(",
"tableName",
"!=",
"null",
")",
"{",
"if",
"(",
"rangeVariable",
"!=",
"null",
"&&",
"rangeVariable",
".",
"rangeTable",
"!=",
"null",
"&&",
"rangeVariable",
".",
"ta... | VoltDB added method to provide detail for a non-catalog-dependent
representation of this HSQLDB object.
@return XML, correctly indented, representing this object. | [
"VoltDB",
"added",
"method",
"to",
"provide",
"detail",
"for",
"a",
"non",
"-",
"catalog",
"-",
"dependent",
"representation",
"of",
"this",
"HSQLDB",
"object",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ExpressionColumn.java#L1320-L1340 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.parseTablesAndParams | void parseTablesAndParams(VoltXMLElement root) {
// Parse parameters first to satisfy a dependency of expression parsing
// which happens during table scan parsing.
parseParameters(root);
parseCommonTableExpressions(root);
for (VoltXMLElement node : root.children) {
... | java | void parseTablesAndParams(VoltXMLElement root) {
// Parse parameters first to satisfy a dependency of expression parsing
// which happens during table scan parsing.
parseParameters(root);
parseCommonTableExpressions(root);
for (VoltXMLElement node : root.children) {
... | [
"void",
"parseTablesAndParams",
"(",
"VoltXMLElement",
"root",
")",
"{",
"// Parse parameters first to satisfy a dependency of expression parsing",
"// which happens during table scan parsing.",
"parseParameters",
"(",
"root",
")",
";",
"parseCommonTableExpressions",
"(",
"root",
"... | Parse tables and parameters
.
@param root
@param db | [
"Parse",
"tables",
"and",
"parameters",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L283-L299 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.parseExpressionNode | private AbstractExpression parseExpressionNode(VoltXMLElement exprNode) {
String elementName = exprNode.name.toLowerCase();
XMLElementExpressionParser parser = m_exprParsers.get(elementName);
if (parser == null) {
throw new PlanningErrorException("Unsupported expression node '" + el... | java | private AbstractExpression parseExpressionNode(VoltXMLElement exprNode) {
String elementName = exprNode.name.toLowerCase();
XMLElementExpressionParser parser = m_exprParsers.get(elementName);
if (parser == null) {
throw new PlanningErrorException("Unsupported expression node '" + el... | [
"private",
"AbstractExpression",
"parseExpressionNode",
"(",
"VoltXMLElement",
"exprNode",
")",
"{",
"String",
"elementName",
"=",
"exprNode",
".",
"name",
".",
"toLowerCase",
"(",
")",
";",
"XMLElementExpressionParser",
"parser",
"=",
"m_exprParsers",
".",
"get",
"... | Given a VoltXMLElement expression node, translate it into an
AbstractExpression. This is mostly a lookup in the table
m_exprParsers. | [
"Given",
"a",
"VoltXMLElement",
"expression",
"node",
"translate",
"it",
"into",
"an",
"AbstractExpression",
".",
"This",
"is",
"mostly",
"a",
"lookup",
"in",
"the",
"table",
"m_exprParsers",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L400-L410 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.parseVectorExpression | private AbstractExpression parseVectorExpression(VoltXMLElement exprNode) {
ArrayList<AbstractExpression> args = new ArrayList<>();
for (VoltXMLElement argNode : exprNode.children) {
assert(argNode != null);
// recursively parse each argument subtree (could be any kind of express... | java | private AbstractExpression parseVectorExpression(VoltXMLElement exprNode) {
ArrayList<AbstractExpression> args = new ArrayList<>();
for (VoltXMLElement argNode : exprNode.children) {
assert(argNode != null);
// recursively parse each argument subtree (could be any kind of express... | [
"private",
"AbstractExpression",
"parseVectorExpression",
"(",
"VoltXMLElement",
"exprNode",
")",
"{",
"ArrayList",
"<",
"AbstractExpression",
">",
"args",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"for",
"(",
"VoltXMLElement",
"argNode",
":",
"exprNode",
".",... | Parse a Vector value for SQL-IN | [
"Parse",
"a",
"Vector",
"value",
"for",
"SQL",
"-",
"IN"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L415-L429 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.parseSubqueryExpression | private SelectSubqueryExpression parseSubqueryExpression(VoltXMLElement exprNode) {
assert(exprNode.children.size() == 1);
VoltXMLElement subqueryElmt = exprNode.children.get(0);
AbstractParsedStmt subqueryStmt = parseSubquery(subqueryElmt);
// add table to the query cache
String... | java | private SelectSubqueryExpression parseSubqueryExpression(VoltXMLElement exprNode) {
assert(exprNode.children.size() == 1);
VoltXMLElement subqueryElmt = exprNode.children.get(0);
AbstractParsedStmt subqueryStmt = parseSubquery(subqueryElmt);
// add table to the query cache
String... | [
"private",
"SelectSubqueryExpression",
"parseSubqueryExpression",
"(",
"VoltXMLElement",
"exprNode",
")",
"{",
"assert",
"(",
"exprNode",
".",
"children",
".",
"size",
"(",
")",
"==",
"1",
")",
";",
"VoltXMLElement",
"subqueryElmt",
"=",
"exprNode",
".",
"children... | Parse an expression subquery | [
"Parse",
"an",
"expression",
"subquery"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L596-L606 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.resolveStmtTableScanByAlias | private StmtTableScan resolveStmtTableScanByAlias(String tableAlias) {
StmtTableScan tableScan = getStmtTableScanByAlias(tableAlias);
if (tableScan != null) {
return tableScan;
}
if (m_parentStmt != null) {
// This may be a correlated subquery
return m... | java | private StmtTableScan resolveStmtTableScanByAlias(String tableAlias) {
StmtTableScan tableScan = getStmtTableScanByAlias(tableAlias);
if (tableScan != null) {
return tableScan;
}
if (m_parentStmt != null) {
// This may be a correlated subquery
return m... | [
"private",
"StmtTableScan",
"resolveStmtTableScanByAlias",
"(",
"String",
"tableAlias",
")",
"{",
"StmtTableScan",
"tableScan",
"=",
"getStmtTableScanByAlias",
"(",
"tableAlias",
")",
";",
"if",
"(",
"tableScan",
"!=",
"null",
")",
"{",
"return",
"tableScan",
";",
... | Return StmtTableScan by table alias. In case of correlated queries,
may need to walk up the statement tree.
@param tableAlias | [
"Return",
"StmtTableScan",
"by",
"table",
"alias",
".",
"In",
"case",
"of",
"correlated",
"queries",
"may",
"need",
"to",
"walk",
"up",
"the",
"statement",
"tree",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L786-L796 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.addTableToStmtCache | protected StmtTableScan addTableToStmtCache(Table table, String tableAlias) {
// Create an index into the query Catalog cache
StmtTableScan tableScan = m_tableAliasMap.get(tableAlias);
if (tableScan == null) {
tableScan = new StmtTargetTableScan(table, tableAlias, m_stmtId);
... | java | protected StmtTableScan addTableToStmtCache(Table table, String tableAlias) {
// Create an index into the query Catalog cache
StmtTableScan tableScan = m_tableAliasMap.get(tableAlias);
if (tableScan == null) {
tableScan = new StmtTargetTableScan(table, tableAlias, m_stmtId);
... | [
"protected",
"StmtTableScan",
"addTableToStmtCache",
"(",
"Table",
"table",
",",
"String",
"tableAlias",
")",
"{",
"// Create an index into the query Catalog cache",
"StmtTableScan",
"tableScan",
"=",
"m_tableAliasMap",
".",
"get",
"(",
"tableAlias",
")",
";",
"if",
"("... | Add a table to the statement cache.
@param table
@param tableAlias
@return the cache entry | [
"Add",
"a",
"table",
"to",
"the",
"statement",
"cache",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L804-L812 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.addSubqueryToStmtCache | protected StmtSubqueryScan addSubqueryToStmtCache(
AbstractParsedStmt subquery, String tableAlias) {
assert(subquery != null);
// If there is no usable alias because the subquery is inside an expression,
// generate a unique one for internal use.
if (tableAlias == null) {
... | java | protected StmtSubqueryScan addSubqueryToStmtCache(
AbstractParsedStmt subquery, String tableAlias) {
assert(subquery != null);
// If there is no usable alias because the subquery is inside an expression,
// generate a unique one for internal use.
if (tableAlias == null) {
... | [
"protected",
"StmtSubqueryScan",
"addSubqueryToStmtCache",
"(",
"AbstractParsedStmt",
"subquery",
",",
"String",
"tableAlias",
")",
"{",
"assert",
"(",
"subquery",
"!=",
"null",
")",
";",
"// If there is no usable alias because the subquery is inside an expression,",
"// genera... | Add a sub-query to the statement cache.
@param subquery
@param tableAlias
@return the cache entry | [
"Add",
"a",
"sub",
"-",
"query",
"to",
"the",
"statement",
"cache",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L820-L833 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.addSimplifiedSubqueryToStmtCache | private StmtTargetTableScan addSimplifiedSubqueryToStmtCache(
StmtSubqueryScan subqueryScan, StmtTargetTableScan tableScan) {
String tableAlias = subqueryScan.getTableAlias();
assert(tableAlias != null);
// It is guaranteed by the canSimplifySubquery that there is
// one and ... | java | private StmtTargetTableScan addSimplifiedSubqueryToStmtCache(
StmtSubqueryScan subqueryScan, StmtTargetTableScan tableScan) {
String tableAlias = subqueryScan.getTableAlias();
assert(tableAlias != null);
// It is guaranteed by the canSimplifySubquery that there is
// one and ... | [
"private",
"StmtTargetTableScan",
"addSimplifiedSubqueryToStmtCache",
"(",
"StmtSubqueryScan",
"subqueryScan",
",",
"StmtTargetTableScan",
"tableScan",
")",
"{",
"String",
"tableAlias",
"=",
"subqueryScan",
".",
"getTableAlias",
"(",
")",
";",
"assert",
"(",
"tableAlias",... | Replace an existing subquery scan with its underlying table scan. The subquery
has already passed all the checks from the canSimplifySubquery method.
Subquery ORDER BY clause is ignored if such exists.
@param subqueryScan subquery scan to simplify
@param tableAlias
@return StmtTargetTableScan | [
"Replace",
"an",
"existing",
"subquery",
"scan",
"with",
"its",
"underlying",
"table",
"scan",
".",
"The",
"subquery",
"has",
"already",
"passed",
"all",
"the",
"checks",
"from",
"the",
"canSimplifySubquery",
"method",
".",
"Subquery",
"ORDER",
"BY",
"clause",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L894-L911 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.replaceExpressionsWithPve | protected AbstractExpression replaceExpressionsWithPve(AbstractExpression expr) {
assert(expr != null);
if (expr instanceof TupleValueExpression) {
int paramIdx = ParameterizationInfo.getNextParamIndex();
ParameterValueExpression pve = new ParameterValueExpression(paramIdx, expr)... | java | protected AbstractExpression replaceExpressionsWithPve(AbstractExpression expr) {
assert(expr != null);
if (expr instanceof TupleValueExpression) {
int paramIdx = ParameterizationInfo.getNextParamIndex();
ParameterValueExpression pve = new ParameterValueExpression(paramIdx, expr)... | [
"protected",
"AbstractExpression",
"replaceExpressionsWithPve",
"(",
"AbstractExpression",
"expr",
")",
"{",
"assert",
"(",
"expr",
"!=",
"null",
")",
";",
"if",
"(",
"expr",
"instanceof",
"TupleValueExpression",
")",
"{",
"int",
"paramIdx",
"=",
"ParameterizationIn... | Helper method to replace all TVEs and aggregated expressions with the corresponding PVEs.
The original expressions are placed into the map to be propagated to the EE.
The key to the map is the parameter index.
@param stmt - subquery statement
@param expr - expression with parent TVEs
@return Expression with parent TV... | [
"Helper",
"method",
"to",
"replace",
"all",
"TVEs",
"and",
"aggregated",
"expressions",
"with",
"the",
"corresponding",
"PVEs",
".",
"The",
"original",
"expressions",
"are",
"placed",
"into",
"the",
"map",
"to",
"be",
"propagated",
"to",
"the",
"EE",
".",
"T... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L1166-L1207 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.resolveCommonTableByName | private StmtCommonTableScan resolveCommonTableByName(String tableName, String tableAlias) {
StmtCommonTableScan answer = null;
StmtCommonTableScanShared scan = null;
for (AbstractParsedStmt scope = this; scope != null && scan == null; scope = scope.getParentStmt()) {
scan = scope.get... | java | private StmtCommonTableScan resolveCommonTableByName(String tableName, String tableAlias) {
StmtCommonTableScan answer = null;
StmtCommonTableScanShared scan = null;
for (AbstractParsedStmt scope = this; scope != null && scan == null; scope = scope.getParentStmt()) {
scan = scope.get... | [
"private",
"StmtCommonTableScan",
"resolveCommonTableByName",
"(",
"String",
"tableName",
",",
"String",
"tableAlias",
")",
"{",
"StmtCommonTableScan",
"answer",
"=",
"null",
";",
"StmtCommonTableScanShared",
"scan",
"=",
"null",
";",
"for",
"(",
"AbstractParsedStmt",
... | Look for a common table by name, possibly in parent scopes.
This is different from resolveStmtTableByAlias in that it
looks for common tables and only by name, not by alias. Of
course, a name and an alias are both strings, so this is kind
of a stylized distinction.
@param tableName
@return | [
"Look",
"for",
"a",
"common",
"table",
"by",
"name",
"possibly",
"in",
"parent",
"scopes",
".",
"This",
"is",
"different",
"from",
"resolveStmtTableByAlias",
"in",
"that",
"it",
"looks",
"for",
"common",
"tables",
"and",
"only",
"by",
"name",
"not",
"by",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L1482-L1492 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.parseParameters | protected void parseParameters(VoltXMLElement root) {
VoltXMLElement paramsNode = null;
for (VoltXMLElement node : root.children) {
if (node.name.equalsIgnoreCase("parameters")) {
paramsNode = node;
break;
}
}
if (paramsNode == null... | java | protected void parseParameters(VoltXMLElement root) {
VoltXMLElement paramsNode = null;
for (VoltXMLElement node : root.children) {
if (node.name.equalsIgnoreCase("parameters")) {
paramsNode = node;
break;
}
}
if (paramsNode == null... | [
"protected",
"void",
"parseParameters",
"(",
"VoltXMLElement",
"root",
")",
"{",
"VoltXMLElement",
"paramsNode",
"=",
"null",
";",
"for",
"(",
"VoltXMLElement",
"node",
":",
"root",
".",
"children",
")",
"{",
"if",
"(",
"node",
".",
"name",
".",
"equalsIgnor... | Populate the statement's paramList from the "parameters" element. Each
parameter has an id and an index, both of which are numeric. It also has
a type and an indication of whether it's a vector parameter. For each
parameter, we create a ParameterValueExpression, named pve, which holds
the type and vector parameter indi... | [
"Populate",
"the",
"statement",
"s",
"paramList",
"from",
"the",
"parameters",
"element",
".",
"Each",
"parameter",
"has",
"an",
"id",
"and",
"an",
"index",
"both",
"of",
"which",
"are",
"numeric",
".",
"It",
"also",
"has",
"a",
"type",
"and",
"an",
"ind... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L1567-L1601 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.promoteUnionParametersFromChild | protected void promoteUnionParametersFromChild(AbstractParsedStmt childStmt) {
getParamsByIndex().putAll(childStmt.getParamsByIndex());
m_parameterTveMap.putAll(childStmt.m_parameterTveMap);
} | java | protected void promoteUnionParametersFromChild(AbstractParsedStmt childStmt) {
getParamsByIndex().putAll(childStmt.getParamsByIndex());
m_parameterTveMap.putAll(childStmt.m_parameterTveMap);
} | [
"protected",
"void",
"promoteUnionParametersFromChild",
"(",
"AbstractParsedStmt",
"childStmt",
")",
"{",
"getParamsByIndex",
"(",
")",
".",
"putAll",
"(",
"childStmt",
".",
"getParamsByIndex",
"(",
")",
")",
";",
"m_parameterTveMap",
".",
"putAll",
"(",
"childStmt"... | in the EE. | [
"in",
"the",
"EE",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L1628-L1631 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.analyzeValueEquivalence | HashMap<AbstractExpression, Set<AbstractExpression>> analyzeValueEquivalence() {
// collect individual where/join expressions
m_joinTree.analyzeJoinExpressions(m_noTableSelectionList);
return m_joinTree.getAllEquivalenceFilters();
} | java | HashMap<AbstractExpression, Set<AbstractExpression>> analyzeValueEquivalence() {
// collect individual where/join expressions
m_joinTree.analyzeJoinExpressions(m_noTableSelectionList);
return m_joinTree.getAllEquivalenceFilters();
} | [
"HashMap",
"<",
"AbstractExpression",
",",
"Set",
"<",
"AbstractExpression",
">",
">",
"analyzeValueEquivalence",
"(",
")",
"{",
"// collect individual where/join expressions",
"m_joinTree",
".",
"analyzeJoinExpressions",
"(",
"m_noTableSelectionList",
")",
";",
"return",
... | Collect value equivalence expressions across the entire SQL statement
@return a map of tuple value expressions to the other expressions,
TupleValueExpressions, ConstantValueExpressions, or ParameterValueExpressions,
that they are constrained to equal. | [
"Collect",
"value",
"equivalence",
"expressions",
"across",
"the",
"entire",
"SQL",
"statement"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L1639-L1643 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.getTableFromDB | protected Table getTableFromDB(String tableName) {
Table table = m_db.getTables().getExact(tableName);
return table;
} | java | protected Table getTableFromDB(String tableName) {
Table table = m_db.getTables().getExact(tableName);
return table;
} | [
"protected",
"Table",
"getTableFromDB",
"(",
"String",
"tableName",
")",
"{",
"Table",
"table",
"=",
"m_db",
".",
"getTables",
"(",
")",
".",
"getExact",
"(",
"tableName",
")",
";",
"return",
"table",
";",
"}"
] | Look up a table by name. This table may be stored in the
local catalog or else the global catalog.
@param tableName
@return | [
"Look",
"up",
"a",
"table",
"by",
"name",
".",
"This",
"table",
"may",
"be",
"stored",
"in",
"the",
"local",
"catalog",
"or",
"else",
"the",
"global",
"catalog",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L1651-L1654 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.parseTableCondition | private AbstractExpression parseTableCondition(VoltXMLElement tableScan,
String joinOrWhere) {
AbstractExpression condExpr = null;
for (VoltXMLElement childNode : tableScan.children) {
if ( ! childNode.name.equalsIgnoreCase(joinOrWhere)) {
continue;
}
... | java | private AbstractExpression parseTableCondition(VoltXMLElement tableScan,
String joinOrWhere) {
AbstractExpression condExpr = null;
for (VoltXMLElement childNode : tableScan.children) {
if ( ! childNode.name.equalsIgnoreCase(joinOrWhere)) {
continue;
}
... | [
"private",
"AbstractExpression",
"parseTableCondition",
"(",
"VoltXMLElement",
"tableScan",
",",
"String",
"joinOrWhere",
")",
"{",
"AbstractExpression",
"condExpr",
"=",
"null",
";",
"for",
"(",
"VoltXMLElement",
"childNode",
":",
"tableScan",
".",
"children",
")",
... | Parse a where or join clause. This behavior is common to all kinds of statements. | [
"Parse",
"a",
"where",
"or",
"join",
"clause",
".",
"This",
"behavior",
"is",
"common",
"to",
"all",
"kinds",
"of",
"statements",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L1735-L1754 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.limitPlanNodeFromXml | LimitPlanNode limitPlanNodeFromXml(VoltXMLElement limitXml, VoltXMLElement offsetXml) {
if (limitXml == null && offsetXml == null) {
return null;
}
String node;
long limitParameterId = -1;
long offsetParameterId = -1;
long limit = -1;
long offset = 0... | java | LimitPlanNode limitPlanNodeFromXml(VoltXMLElement limitXml, VoltXMLElement offsetXml) {
if (limitXml == null && offsetXml == null) {
return null;
}
String node;
long limitParameterId = -1;
long offsetParameterId = -1;
long limit = -1;
long offset = 0... | [
"LimitPlanNode",
"limitPlanNodeFromXml",
"(",
"VoltXMLElement",
"limitXml",
",",
"VoltXMLElement",
"offsetXml",
")",
"{",
"if",
"(",
"limitXml",
"==",
"null",
"&&",
"offsetXml",
"==",
"null",
")",
"{",
"return",
"null",
";",
"}",
"String",
"node",
";",
"long",... | Produce a LimitPlanNode from the given XML
@param limitXml Volt XML for limit
@param offsetXml Volt XML for offset
@return An instance of LimitPlanNode for the given XML | [
"Produce",
"a",
"LimitPlanNode",
"from",
"the",
"given",
"XML"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L1848-L1909 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.orderByColumnsCoverUniqueKeys | protected boolean orderByColumnsCoverUniqueKeys() {
// In theory, if EVERY table in the query has a uniqueness constraint
// (primary key or other unique index) on columns that are all listed in the ORDER BY values,
// the result is deterministic.
// This holds regardless of whether the ... | java | protected boolean orderByColumnsCoverUniqueKeys() {
// In theory, if EVERY table in the query has a uniqueness constraint
// (primary key or other unique index) on columns that are all listed in the ORDER BY values,
// the result is deterministic.
// This holds regardless of whether the ... | [
"protected",
"boolean",
"orderByColumnsCoverUniqueKeys",
"(",
")",
"{",
"// In theory, if EVERY table in the query has a uniqueness constraint",
"// (primary key or other unique index) on columns that are all listed in the ORDER BY values,",
"// the result is deterministic.",
"// This holds regard... | Order by Columns or expressions has to operate on the display columns or expressions.
@return | [
"Order",
"by",
"Columns",
"or",
"expressions",
"has",
"to",
"operate",
"on",
"the",
"display",
"columns",
"or",
"expressions",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L1915-L2045 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.addHonoraryOrderByExpressions | protected void addHonoraryOrderByExpressions(
HashSet<AbstractExpression> orderByExprs,
List<ParsedColInfo> candidateColumns) {
// If there is not exactly one table scan we will not proceed.
// We don't really know how to make indices work with joins,
// and there is noth... | java | protected void addHonoraryOrderByExpressions(
HashSet<AbstractExpression> orderByExprs,
List<ParsedColInfo> candidateColumns) {
// If there is not exactly one table scan we will not proceed.
// We don't really know how to make indices work with joins,
// and there is noth... | [
"protected",
"void",
"addHonoraryOrderByExpressions",
"(",
"HashSet",
"<",
"AbstractExpression",
">",
"orderByExprs",
",",
"List",
"<",
"ParsedColInfo",
">",
"candidateColumns",
")",
"{",
"// If there is not exactly one table scan we will not proceed.",
"// We don't really know h... | Given a set of order-by expressions and a select list, which is a list of
columns, each with an expression and an alias, expand the order-by list
with new expressions which could be on the order-by list without changing
the sort order and which are otherwise helpful. | [
"Given",
"a",
"set",
"of",
"order",
"-",
"by",
"expressions",
"and",
"a",
"select",
"list",
"which",
"is",
"a",
"list",
"of",
"columns",
"each",
"with",
"an",
"expression",
"and",
"an",
"alias",
"expand",
"the",
"order",
"-",
"by",
"list",
"with",
"new... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L2053-L2157 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.producesOneRowOutput | protected boolean producesOneRowOutput () {
if (m_tableAliasMap.size() != 1) {
return false;
}
// Get the table. There's only one.
StmtTableScan scan = m_tableAliasMap.values().iterator().next();
Table table = getTableFromDB(scan.getTableName());
// May be s... | java | protected boolean producesOneRowOutput () {
if (m_tableAliasMap.size() != 1) {
return false;
}
// Get the table. There's only one.
StmtTableScan scan = m_tableAliasMap.values().iterator().next();
Table table = getTableFromDB(scan.getTableName());
// May be s... | [
"protected",
"boolean",
"producesOneRowOutput",
"(",
")",
"{",
"if",
"(",
"m_tableAliasMap",
".",
"size",
"(",
")",
"!=",
"1",
")",
"{",
"return",
"false",
";",
"}",
"// Get the table. There's only one.",
"StmtTableScan",
"scan",
"=",
"m_tableAliasMap",
".",
"v... | row else false | [
"row",
"else",
"false"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L2282-L2353 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/AbstractParsedStmt.java | AbstractParsedStmt.calculateUDFDependees | public Collection<String> calculateUDFDependees() {
List<String> answer = new ArrayList<>();
Collection<AbstractExpression> fCalls = findAllSubexpressionsOfClass(FunctionExpression.class);
for (AbstractExpression fCall : fCalls) {
FunctionExpression fexpr = (FunctionExpression)fCall;... | java | public Collection<String> calculateUDFDependees() {
List<String> answer = new ArrayList<>();
Collection<AbstractExpression> fCalls = findAllSubexpressionsOfClass(FunctionExpression.class);
for (AbstractExpression fCall : fCalls) {
FunctionExpression fexpr = (FunctionExpression)fCall;... | [
"public",
"Collection",
"<",
"String",
">",
"calculateUDFDependees",
"(",
")",
"{",
"List",
"<",
"String",
">",
"answer",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"Collection",
"<",
"AbstractExpression",
">",
"fCalls",
"=",
"findAllSubexpressionsOfClass",
... | Calculate the UDF dependees. These are the UDFs called in an expression
in this procedure.
@return The list of names of UDF dependees. These are function names, and
should all be in lower case. | [
"Calculate",
"the",
"UDF",
"dependees",
".",
"These",
"are",
"the",
"UDFs",
"called",
"in",
"an",
"expression",
"in",
"this",
"procedure",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/AbstractParsedStmt.java#L2382-L2392 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/CompiledPlan.java | CompiledPlan.statementGuaranteesDeterminism | public void statementGuaranteesDeterminism(boolean hasLimitOrOffset,
boolean order,
String contentDeterminismDetail) {
m_statementHasLimitOrOffset = hasLimitOrOffset;
m_statementIsOrderDeterministic = order;
... | java | public void statementGuaranteesDeterminism(boolean hasLimitOrOffset,
boolean order,
String contentDeterminismDetail) {
m_statementHasLimitOrOffset = hasLimitOrOffset;
m_statementIsOrderDeterministic = order;
... | [
"public",
"void",
"statementGuaranteesDeterminism",
"(",
"boolean",
"hasLimitOrOffset",
",",
"boolean",
"order",
",",
"String",
"contentDeterminismDetail",
")",
"{",
"m_statementHasLimitOrOffset",
"=",
"hasLimitOrOffset",
";",
"m_statementIsOrderDeterministic",
"=",
"order",
... | Mark the level of result determinism imposed by the statement, which can
save us from a difficult determination based on the plan graph. | [
"Mark",
"the",
"level",
"of",
"result",
"determinism",
"imposed",
"by",
"the",
"statement",
"which",
"can",
"save",
"us",
"from",
"a",
"difficult",
"determination",
"based",
"on",
"the",
"plan",
"graph",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/CompiledPlan.java#L133-L141 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/CompiledPlan.java | CompiledPlan.setParamIndexes | private static void setParamIndexes(BitSet ints, List<AbstractExpression> params) {
for(AbstractExpression ae : params) {
assert(ae instanceof ParameterValueExpression);
ParameterValueExpression pve = (ParameterValueExpression) ae;
int param = pve.getParameterIndex();
... | java | private static void setParamIndexes(BitSet ints, List<AbstractExpression> params) {
for(AbstractExpression ae : params) {
assert(ae instanceof ParameterValueExpression);
ParameterValueExpression pve = (ParameterValueExpression) ae;
int param = pve.getParameterIndex();
... | [
"private",
"static",
"void",
"setParamIndexes",
"(",
"BitSet",
"ints",
",",
"List",
"<",
"AbstractExpression",
">",
"params",
")",
"{",
"for",
"(",
"AbstractExpression",
"ae",
":",
"params",
")",
"{",
"assert",
"(",
"ae",
"instanceof",
"ParameterValueExpression"... | sources of bindings, IndexScans and IndexCounts. | [
"sources",
"of",
"bindings",
"IndexScans",
"and",
"IndexCounts",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/CompiledPlan.java#L230-L237 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/CompiledPlan.java | CompiledPlan.bitSetToIntVector | private static int[] bitSetToIntVector(BitSet ints) {
int intCount = ints.cardinality();
if (intCount == 0) {
return null;
}
int[] result = new int[intCount];
int nextBit = ints.nextSetBit(0);
for (int ii = 0; ii < intCount; ii++) {
assert(nextBit ... | java | private static int[] bitSetToIntVector(BitSet ints) {
int intCount = ints.cardinality();
if (intCount == 0) {
return null;
}
int[] result = new int[intCount];
int nextBit = ints.nextSetBit(0);
for (int ii = 0; ii < intCount; ii++) {
assert(nextBit ... | [
"private",
"static",
"int",
"[",
"]",
"bitSetToIntVector",
"(",
"BitSet",
"ints",
")",
"{",
"int",
"intCount",
"=",
"ints",
".",
"cardinality",
"(",
")",
";",
"if",
"(",
"intCount",
"==",
"0",
")",
"{",
"return",
"null",
";",
"}",
"int",
"[",
"]",
... | to convert the set bits to their integer indexes. | [
"to",
"convert",
"the",
"set",
"bits",
"to",
"their",
"integer",
"indexes",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/CompiledPlan.java#L241-L255 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/CompiledPlan.java | CompiledPlan.parameterTypes | public VoltType[] parameterTypes() {
if (m_parameterTypes == null) {
m_parameterTypes = new VoltType[getParameters().length];
int ii = 0;
for (ParameterValueExpression param : getParameters()) {
m_parameterTypes[ii++] = param.getValueType();
}
... | java | public VoltType[] parameterTypes() {
if (m_parameterTypes == null) {
m_parameterTypes = new VoltType[getParameters().length];
int ii = 0;
for (ParameterValueExpression param : getParameters()) {
m_parameterTypes[ii++] = param.getValueType();
}
... | [
"public",
"VoltType",
"[",
"]",
"parameterTypes",
"(",
")",
"{",
"if",
"(",
"m_parameterTypes",
"==",
"null",
")",
"{",
"m_parameterTypes",
"=",
"new",
"VoltType",
"[",
"getParameters",
"(",
")",
".",
"length",
"]",
";",
"int",
"ii",
"=",
"0",
";",
"fo... | This is assumed to be called only after parameters has been fully initialized. | [
"This",
"is",
"assumed",
"to",
"be",
"called",
"only",
"after",
"parameters",
"has",
"been",
"fully",
"initialized",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/CompiledPlan.java#L287-L296 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java | DatabaseManager.newSession | public static Session newSession(int dbID, String user, String password,
int timeZoneSeconds) {
Database db = (Database) databaseIDMap.get(dbID);
if (db == null) {
return null;
}
Session session = db.connect(user, password, timeZoneSeco... | java | public static Session newSession(int dbID, String user, String password,
int timeZoneSeconds) {
Database db = (Database) databaseIDMap.get(dbID);
if (db == null) {
return null;
}
Session session = db.connect(user, password, timeZoneSeco... | [
"public",
"static",
"Session",
"newSession",
"(",
"int",
"dbID",
",",
"String",
"user",
",",
"String",
"password",
",",
"int",
"timeZoneSeconds",
")",
"{",
"Database",
"db",
"=",
"(",
"Database",
")",
"databaseIDMap",
".",
"get",
"(",
"dbID",
")",
";",
"... | Used by server to open a new session | [
"Used",
"by",
"server",
"to",
"open",
"a",
"new",
"session"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java#L147-L161 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java | DatabaseManager.newSession | public static Session newSession(String type, String path, String user,
String password, HsqlProperties props,
int timeZoneSeconds) {
Database db = getDatabase(type, path, props);
if (db == null) {
return null;
... | java | public static Session newSession(String type, String path, String user,
String password, HsqlProperties props,
int timeZoneSeconds) {
Database db = getDatabase(type, path, props);
if (db == null) {
return null;
... | [
"public",
"static",
"Session",
"newSession",
"(",
"String",
"type",
",",
"String",
"path",
",",
"String",
"user",
",",
"String",
"password",
",",
"HsqlProperties",
"props",
",",
"int",
"timeZoneSeconds",
")",
"{",
"Database",
"db",
"=",
"getDatabase",
"(",
"... | Used by in-process connections and by Servlet | [
"Used",
"by",
"in",
"-",
"process",
"connections",
"and",
"by",
"Servlet"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java#L166-L177 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java | DatabaseManager.lookupDatabaseObject | public static synchronized Database lookupDatabaseObject(String type,
String path) {
// A VoltDB extension to work around ENG-6044
/* disabled 14 lines ...
Object key = path;
HashMap databaseMap;
if (type == DatabaseURL.S_FILE) {
databaseMap = fileDatab... | java | public static synchronized Database lookupDatabaseObject(String type,
String path) {
// A VoltDB extension to work around ENG-6044
/* disabled 14 lines ...
Object key = path;
HashMap databaseMap;
if (type == DatabaseURL.S_FILE) {
databaseMap = fileDatab... | [
"public",
"static",
"synchronized",
"Database",
"lookupDatabaseObject",
"(",
"String",
"type",
",",
"String",
"path",
")",
"{",
"// A VoltDB extension to work around ENG-6044",
"/* disabled 14 lines ...\n Object key = path;\n HashMap databaseMap;\n\n if (type == Dat... | Looks up database of a given type and path in the registry. Returns
null if there is none. | [
"Looks",
"up",
"database",
"of",
"a",
"given",
"type",
"and",
"path",
"in",
"the",
"registry",
".",
"Returns",
"null",
"if",
"there",
"is",
"none",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java#L321-L348 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java | DatabaseManager.addDatabaseObject | private static synchronized void addDatabaseObject(String type,
String path, Database db) {
// A VoltDB extension to work around ENG-6044
/* disable 15 lines ...
Object key = path;
HashMap databaseMap;
if (type == DatabaseURL.S_FILE) {
databaseMap = fi... | java | private static synchronized void addDatabaseObject(String type,
String path, Database db) {
// A VoltDB extension to work around ENG-6044
/* disable 15 lines ...
Object key = path;
HashMap databaseMap;
if (type == DatabaseURL.S_FILE) {
databaseMap = fi... | [
"private",
"static",
"synchronized",
"void",
"addDatabaseObject",
"(",
"String",
"type",
",",
"String",
"path",
",",
"Database",
"db",
")",
"{",
"// A VoltDB extension to work around ENG-6044",
"/* disable 15 lines ...\n Object key = path;\n\n HashMap databaseMap;\n\... | Adds a database to the registry. Returns
null if there is none. | [
"Adds",
"a",
"database",
"to",
"the",
"registry",
".",
"Returns",
"null",
"if",
"there",
"is",
"none",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java#L354-L383 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java | DatabaseManager.removeDatabase | static void removeDatabase(Database database) {
int dbID = database.databaseID;
String type = database.getType();
String path = database.getPath();
// A VoltDB extension to work around ENG-6044
/* disable 2 lines ...
Object key = path;
HashMap databaseMap... | java | static void removeDatabase(Database database) {
int dbID = database.databaseID;
String type = database.getType();
String path = database.getPath();
// A VoltDB extension to work around ENG-6044
/* disable 2 lines ...
Object key = path;
HashMap databaseMap... | [
"static",
"void",
"removeDatabase",
"(",
"Database",
"database",
")",
"{",
"int",
"dbID",
"=",
"database",
".",
"databaseID",
";",
"String",
"type",
"=",
"database",
".",
"getType",
"(",
")",
";",
"String",
"path",
"=",
"database",
".",
"getPath",
"(",
"... | Removes the database from registry. | [
"Removes",
"the",
"database",
"from",
"registry",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java#L388-L428 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java | DatabaseManager.deRegisterServer | private static void deRegisterServer(Server server, Database db) {
Iterator it = serverMap.values().iterator();
for (; it.hasNext(); ) {
HashSet databases = (HashSet) it.next();
databases.remove(db);
if (databases.isEmpty()) {
it.remove();
... | java | private static void deRegisterServer(Server server, Database db) {
Iterator it = serverMap.values().iterator();
for (; it.hasNext(); ) {
HashSet databases = (HashSet) it.next();
databases.remove(db);
if (databases.isEmpty()) {
it.remove();
... | [
"private",
"static",
"void",
"deRegisterServer",
"(",
"Server",
"server",
",",
"Database",
"db",
")",
"{",
"Iterator",
"it",
"=",
"serverMap",
".",
"values",
"(",
")",
".",
"iterator",
"(",
")",
";",
"for",
"(",
";",
"it",
".",
"hasNext",
"(",
")",
"... | Deregisters a server as serving a given database. Not yet used. | [
"Deregisters",
"a",
"server",
"as",
"serving",
"a",
"given",
"database",
".",
"Not",
"yet",
"used",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java#L449-L462 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java | DatabaseManager.registerServer | private static void registerServer(Server server, Database db) {
if (!serverMap.containsKey(server)) {
serverMap.put(server, new HashSet());
}
HashSet databases = (HashSet) serverMap.get(server);
databases.add(db);
} | java | private static void registerServer(Server server, Database db) {
if (!serverMap.containsKey(server)) {
serverMap.put(server, new HashSet());
}
HashSet databases = (HashSet) serverMap.get(server);
databases.add(db);
} | [
"private",
"static",
"void",
"registerServer",
"(",
"Server",
"server",
",",
"Database",
"db",
")",
"{",
"if",
"(",
"!",
"serverMap",
".",
"containsKey",
"(",
"server",
")",
")",
"{",
"serverMap",
".",
"put",
"(",
"server",
",",
"new",
"HashSet",
"(",
... | Registers a server as serving a given database. | [
"Registers",
"a",
"server",
"as",
"serving",
"a",
"given",
"database",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java#L467-L476 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java | DatabaseManager.notifyServers | private static void notifyServers(Database db) {
Iterator it = serverMap.keySet().iterator();
for (; it.hasNext(); ) {
Server server = (Server) it.next();
HashSet databases = (HashSet) serverMap.get(server);
if (databases.contains(db)) {
// A VoltDB extension t... | java | private static void notifyServers(Database db) {
Iterator it = serverMap.keySet().iterator();
for (; it.hasNext(); ) {
Server server = (Server) it.next();
HashSet databases = (HashSet) serverMap.get(server);
if (databases.contains(db)) {
// A VoltDB extension t... | [
"private",
"static",
"void",
"notifyServers",
"(",
"Database",
"db",
")",
"{",
"Iterator",
"it",
"=",
"serverMap",
".",
"keySet",
"(",
")",
".",
"iterator",
"(",
")",
";",
"for",
"(",
";",
"it",
".",
"hasNext",
"(",
")",
";",
")",
"{",
"Server",
"s... | Notifies all servers that serve the database that the database has been
shutdown. | [
"Notifies",
"all",
"servers",
"that",
"serve",
"the",
"database",
"that",
"the",
"database",
"has",
"been",
"shutdown",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java#L482-L499 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java | DatabaseManager.filePathToKey | private static String filePathToKey(String path) {
try {
return FileUtil.getDefaultInstance().canonicalPath(path);
} catch (Exception e) {
return path;
}
} | java | private static String filePathToKey(String path) {
try {
return FileUtil.getDefaultInstance().canonicalPath(path);
} catch (Exception e) {
return path;
}
} | [
"private",
"static",
"String",
"filePathToKey",
"(",
"String",
"path",
")",
"{",
"try",
"{",
"return",
"FileUtil",
".",
"getDefaultInstance",
"(",
")",
".",
"canonicalPath",
"(",
"path",
")",
";",
"}",
"catch",
"(",
"Exception",
"e",
")",
"{",
"return",
... | thrown exception to an HsqlException in the process | [
"thrown",
"exception",
"to",
"an",
"HsqlException",
"in",
"the",
"process"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/DatabaseManager.java#L526-L533 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLLexer.java | SQLLexer.isComment | public static boolean isComment(String sql)
{
Matcher commentMatcher = PAT_SINGLE_LINE_COMMENT.matcher(sql);
return commentMatcher.matches();
} | java | public static boolean isComment(String sql)
{
Matcher commentMatcher = PAT_SINGLE_LINE_COMMENT.matcher(sql);
return commentMatcher.matches();
} | [
"public",
"static",
"boolean",
"isComment",
"(",
"String",
"sql",
")",
"{",
"Matcher",
"commentMatcher",
"=",
"PAT_SINGLE_LINE_COMMENT",
".",
"matcher",
"(",
"sql",
")",
";",
"return",
"commentMatcher",
".",
"matches",
"(",
")",
";",
"}"
] | Check if a SQL string is a comment.
@param sql SQL string
@return true if it's a comment | [
"Check",
"if",
"a",
"SQL",
"string",
"is",
"a",
"comment",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLLexer.java#L167-L171 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLLexer.java | SQLLexer.extractDDLToken | public static String extractDDLToken(String sql)
{
String ddlToken = null;
Matcher ddlMatcher = PAT_ANY_DDL_FIRST_TOKEN.matcher(sql);
if (ddlMatcher.find()) {
ddlToken = ddlMatcher.group(1).toLowerCase();
}
return ddlToken;
} | java | public static String extractDDLToken(String sql)
{
String ddlToken = null;
Matcher ddlMatcher = PAT_ANY_DDL_FIRST_TOKEN.matcher(sql);
if (ddlMatcher.find()) {
ddlToken = ddlMatcher.group(1).toLowerCase();
}
return ddlToken;
} | [
"public",
"static",
"String",
"extractDDLToken",
"(",
"String",
"sql",
")",
"{",
"String",
"ddlToken",
"=",
"null",
";",
"Matcher",
"ddlMatcher",
"=",
"PAT_ANY_DDL_FIRST_TOKEN",
".",
"matcher",
"(",
"sql",
")",
";",
"if",
"(",
"ddlMatcher",
".",
"find",
"(",... | Get the DDL token, if any, at the start of this statement.
@return returns token, or null if it wasn't DDL | [
"Get",
"the",
"DDL",
"token",
"if",
"any",
"at",
"the",
"start",
"of",
"this",
"statement",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLLexer.java#L187-L195 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLLexer.java | SQLLexer.extractDDLTableName | public static String extractDDLTableName(String sql)
{
Matcher matcher = PAT_TABLE_DDL_PREAMBLE.matcher(sql);
if (matcher.find()) {
return matcher.group(2).toLowerCase();
}
return null;
} | java | public static String extractDDLTableName(String sql)
{
Matcher matcher = PAT_TABLE_DDL_PREAMBLE.matcher(sql);
if (matcher.find()) {
return matcher.group(2).toLowerCase();
}
return null;
} | [
"public",
"static",
"String",
"extractDDLTableName",
"(",
"String",
"sql",
")",
"{",
"Matcher",
"matcher",
"=",
"PAT_TABLE_DDL_PREAMBLE",
".",
"matcher",
"(",
"sql",
")",
";",
"if",
"(",
"matcher",
".",
"find",
"(",
")",
")",
"{",
"return",
"matcher",
".",... | Get the table name for a CREATE or DROP DDL statement.
@return returns token, or null if the DDL isn't (CREATE|DROP) TABLE | [
"Get",
"the",
"table",
"name",
"for",
"a",
"CREATE",
"or",
"DROP",
"DDL",
"statement",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLLexer.java#L248-L255 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLLexer.java | SQLLexer.checkPermitted | public static String checkPermitted(String sql)
{
/*
* IMPORTANT: Black-lists are checked first because they know more about
* what they don't like about a statement and can provide a better message.
* It requires that black-lists patterns be very selective and that they
... | java | public static String checkPermitted(String sql)
{
/*
* IMPORTANT: Black-lists are checked first because they know more about
* what they don't like about a statement and can provide a better message.
* It requires that black-lists patterns be very selective and that they
... | [
"public",
"static",
"String",
"checkPermitted",
"(",
"String",
"sql",
")",
"{",
"/*\n * IMPORTANT: Black-lists are checked first because they know more about\n * what they don't like about a statement and can provide a better message.\n * It requires that black-lists patte... | Naive filtering for stuff we haven't implemented yet.
Hopefully this gets whittled away and eventually disappears.
@param sql statement to check
@return rejection explanation string or null if accepted | [
"Naive",
"filtering",
"for",
"stuff",
"we",
"haven",
"t",
"implemented",
"yet",
".",
"Hopefully",
"this",
"gets",
"whittled",
"away",
"and",
"eventually",
"disappears",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLLexer.java#L264-L297 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLLexer.java | SQLLexer.matchesStringAtIndex | static private boolean matchesStringAtIndex(char[] buf, int index, String str) {
int strLength = str.length();
if (index + strLength > buf.length) {
return false;
}
for (int i = 0; i < strLength; ++i) {
if (buf[index + i] != str.charAt(i)) {
retur... | java | static private boolean matchesStringAtIndex(char[] buf, int index, String str) {
int strLength = str.length();
if (index + strLength > buf.length) {
return false;
}
for (int i = 0; i < strLength; ++i) {
if (buf[index + i] != str.charAt(i)) {
retur... | [
"static",
"private",
"boolean",
"matchesStringAtIndex",
"(",
"char",
"[",
"]",
"buf",
",",
"int",
"index",
",",
"String",
"str",
")",
"{",
"int",
"strLength",
"=",
"str",
".",
"length",
"(",
")",
";",
"if",
"(",
"index",
"+",
"strLength",
">",
"buf",
... | Determine if a character buffer contains the specified string a the specified index.
Avoids an array index exception if the buffer is too short.
@param buf a character buffer
@param index an offset into the buffer
@param str the string to look for
@return true if the buffer contains the specified string | [
"Determine",
"if",
"a",
"character",
"buffer",
"contains",
"the",
"specified",
"string",
"a",
"the",
"specified",
"index",
".",
"Avoids",
"an",
"array",
"index",
"exception",
"if",
"the",
"buffer",
"is",
"too",
"short",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLLexer.java#L395-L408 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLLexer.java | SQLLexer.removeCStyleComments | private static String removeCStyleComments(String ddl)
{
// Avoid Apache commons StringUtils.join() to minimize client dependencies.
StringBuilder sb = new StringBuilder();
for (String part : PAT_STRIP_CSTYLE_COMMENTS.split(ddl)) {
sb.append(part);
}
return sb.toS... | java | private static String removeCStyleComments(String ddl)
{
// Avoid Apache commons StringUtils.join() to minimize client dependencies.
StringBuilder sb = new StringBuilder();
for (String part : PAT_STRIP_CSTYLE_COMMENTS.split(ddl)) {
sb.append(part);
}
return sb.toS... | [
"private",
"static",
"String",
"removeCStyleComments",
"(",
"String",
"ddl",
")",
"{",
"// Avoid Apache commons StringUtils.join() to minimize client dependencies.",
"StringBuilder",
"sb",
"=",
"new",
"StringBuilder",
"(",
")",
";",
"for",
"(",
"String",
"part",
":",
"P... | Remove c-style comments from a string aggressively | [
"Remove",
"c",
"-",
"style",
"comments",
"from",
"a",
"string",
"aggressively"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLLexer.java#L677-L685 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLLexer.java | SQLLexer.findObjectToken | private static ObjectToken findObjectToken(String objectTypeName)
{
if (objectTypeName != null) {
for (ObjectToken ot : OBJECT_TOKENS) {
if (ot.token.equalsIgnoreCase(objectTypeName)) {
return ot;
}
}
}
return null;
... | java | private static ObjectToken findObjectToken(String objectTypeName)
{
if (objectTypeName != null) {
for (ObjectToken ot : OBJECT_TOKENS) {
if (ot.token.equalsIgnoreCase(objectTypeName)) {
return ot;
}
}
}
return null;
... | [
"private",
"static",
"ObjectToken",
"findObjectToken",
"(",
"String",
"objectTypeName",
")",
"{",
"if",
"(",
"objectTypeName",
"!=",
"null",
")",
"{",
"for",
"(",
"ObjectToken",
"ot",
":",
"OBJECT_TOKENS",
")",
"{",
"if",
"(",
"ot",
".",
"token",
".",
"equ... | Find information about an object type token, if it's a known object type.
@param objectTypeName object type name to look up
@return object token information or null if it wasn't found | [
"Find",
"information",
"about",
"an",
"object",
"type",
"token",
"if",
"it",
"s",
"a",
"known",
"object",
"type",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLLexer.java#L692-L702 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TriggerDef.java | TriggerDef.pushPair | synchronized void pushPair(Session session, Object[] row1, Object[] row2) {
if (maxRowsQueued == 0) {
trigger.fire(triggerType, name.name, table.getName().name, row1,
row2);
return;
}
if (rowsQueued >= maxRowsQueued) {
if (nowait) {... | java | synchronized void pushPair(Session session, Object[] row1, Object[] row2) {
if (maxRowsQueued == 0) {
trigger.fire(triggerType, name.name, table.getName().name, row1,
row2);
return;
}
if (rowsQueued >= maxRowsQueued) {
if (nowait) {... | [
"synchronized",
"void",
"pushPair",
"(",
"Session",
"session",
",",
"Object",
"[",
"]",
"row1",
",",
"Object",
"[",
"]",
"row2",
")",
"{",
"if",
"(",
"maxRowsQueued",
"==",
"0",
")",
"{",
"trigger",
".",
"fire",
"(",
"triggerType",
",",
"name",
".",
... | The main thread tells the trigger thread to fire by this call.
If this Trigger is not threaded then the fire method is caled
immediately and executed by the main thread. Otherwise, the row
data objects are added to the queue to be used by the Trigger thread.
@param row1
@param row2 | [
"The",
"main",
"thread",
"tells",
"the",
"trigger",
"thread",
"to",
"fire",
"by",
"this",
"call",
".",
"If",
"this",
"Trigger",
"is",
"not",
"threaded",
"then",
"the",
"fire",
"method",
"is",
"caled",
"immediately",
"and",
"executed",
"by",
"the",
"main",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TriggerDef.java#L445-L473 | train |
VoltDB/voltdb | src/frontend/org/voltdb/compiler/PlannerTool.java | PlannerTool.planSqlCore | public synchronized CompiledPlan planSqlCore(String sql, StatementPartitioning partitioning) {
TrivialCostModel costModel = new TrivialCostModel();
DatabaseEstimates estimates = new DatabaseEstimates();
CompiledPlan plan = null;
// This try-with-resources block acquires a global lock on... | java | public synchronized CompiledPlan planSqlCore(String sql, StatementPartitioning partitioning) {
TrivialCostModel costModel = new TrivialCostModel();
DatabaseEstimates estimates = new DatabaseEstimates();
CompiledPlan plan = null;
// This try-with-resources block acquires a global lock on... | [
"public",
"synchronized",
"CompiledPlan",
"planSqlCore",
"(",
"String",
"sql",
",",
"StatementPartitioning",
"partitioning",
")",
"{",
"TrivialCostModel",
"costModel",
"=",
"new",
"TrivialCostModel",
"(",
")",
";",
"DatabaseEstimates",
"estimates",
"=",
"new",
"Databa... | Stripped down compile that is ONLY used to plan default procedures. | [
"Stripped",
"down",
"compile",
"that",
"is",
"ONLY",
"used",
"to",
"plan",
"default",
"procedures",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/compiler/PlannerTool.java#L147-L185 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StatsAgent.java | StatsAgent.isReadOnlyProcedure | private boolean isReadOnlyProcedure(String pname) {
final Boolean b = m_procedureInfo.get().get(pname);
if (b == null) {
return false;
}
return b;
} | java | private boolean isReadOnlyProcedure(String pname) {
final Boolean b = m_procedureInfo.get().get(pname);
if (b == null) {
return false;
}
return b;
} | [
"private",
"boolean",
"isReadOnlyProcedure",
"(",
"String",
"pname",
")",
"{",
"final",
"Boolean",
"b",
"=",
"m_procedureInfo",
".",
"get",
"(",
")",
".",
"get",
"(",
"pname",
")",
";",
"if",
"(",
"b",
"==",
"null",
")",
"{",
"return",
"false",
";",
... | Check if procedure is readonly?
@param pname
@return | [
"Check",
"if",
"procedure",
"is",
"readonly?"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StatsAgent.java#L118-L124 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StatsAgent.java | StatsAgent.aggregateProcedureProfileStats | private VoltTable[] aggregateProcedureProfileStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
StatsProcProfTable timeTable = new StatsProcProfTable();
baseStats[0].resetRowPosition();
while (baseStats[0].advance... | java | private VoltTable[] aggregateProcedureProfileStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
StatsProcProfTable timeTable = new StatsProcProfTable();
baseStats[0].resetRowPosition();
while (baseStats[0].advance... | [
"private",
"VoltTable",
"[",
"]",
"aggregateProcedureProfileStats",
"(",
"VoltTable",
"[",
"]",
"baseStats",
")",
"{",
"if",
"(",
"baseStats",
"==",
"null",
"||",
"baseStats",
".",
"length",
"!=",
"1",
")",
"{",
"return",
"baseStats",
";",
"}",
"StatsProcPro... | Produce PROCEDUREPROFILE aggregation of PROCEDURE subselector | [
"Produce",
"PROCEDUREPROFILE",
"aggregation",
"of",
"PROCEDURE",
"subselector"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StatsAgent.java#L189-L223 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StatsAgent.java | StatsAgent.aggregateProcedureInputStats | private VoltTable[] aggregateProcedureInputStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
StatsProcInputTable timeTable = new StatsProcInputTable();
baseStats[0].resetRowPosition();
while (baseStats[0].advance... | java | private VoltTable[] aggregateProcedureInputStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
StatsProcInputTable timeTable = new StatsProcInputTable();
baseStats[0].resetRowPosition();
while (baseStats[0].advance... | [
"private",
"VoltTable",
"[",
"]",
"aggregateProcedureInputStats",
"(",
"VoltTable",
"[",
"]",
"baseStats",
")",
"{",
"if",
"(",
"baseStats",
"==",
"null",
"||",
"baseStats",
".",
"length",
"!=",
"1",
")",
"{",
"return",
"baseStats",
";",
"}",
"StatsProcInput... | Produce PROCEDUREINPUT aggregation of PROCEDURE subselector | [
"Produce",
"PROCEDUREINPUT",
"aggregation",
"of",
"PROCEDURE",
"subselector"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StatsAgent.java#L227-L259 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StatsAgent.java | StatsAgent.aggregateProcedureOutputStats | private VoltTable[] aggregateProcedureOutputStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
StatsProcOutputTable timeTable = new StatsProcOutputTable();
baseStats[0].resetRowPosition();
while (baseStats[0].adva... | java | private VoltTable[] aggregateProcedureOutputStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
StatsProcOutputTable timeTable = new StatsProcOutputTable();
baseStats[0].resetRowPosition();
while (baseStats[0].adva... | [
"private",
"VoltTable",
"[",
"]",
"aggregateProcedureOutputStats",
"(",
"VoltTable",
"[",
"]",
"baseStats",
")",
"{",
"if",
"(",
"baseStats",
"==",
"null",
"||",
"baseStats",
".",
"length",
"!=",
"1",
")",
"{",
"return",
"baseStats",
";",
"}",
"StatsProcOutp... | Produce PROCEDUREOUTPUT aggregation of PROCEDURE subselector | [
"Produce",
"PROCEDUREOUTPUT",
"aggregation",
"of",
"PROCEDURE",
"subselector"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StatsAgent.java#L265-L297 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StatsAgent.java | StatsAgent.notifyOfCatalogUpdate | public void notifyOfCatalogUpdate() {
m_procedureInfo = getProcedureInformationfoSupplier();
m_registeredStatsSources.put(StatsSelector.PROCEDURE,
new NonBlockingHashMap<Long, NonBlockingHashSet<StatsSource>>());
} | java | public void notifyOfCatalogUpdate() {
m_procedureInfo = getProcedureInformationfoSupplier();
m_registeredStatsSources.put(StatsSelector.PROCEDURE,
new NonBlockingHashMap<Long, NonBlockingHashSet<StatsSource>>());
} | [
"public",
"void",
"notifyOfCatalogUpdate",
"(",
")",
"{",
"m_procedureInfo",
"=",
"getProcedureInformationfoSupplier",
"(",
")",
";",
"m_registeredStatsSources",
".",
"put",
"(",
"StatsSelector",
".",
"PROCEDURE",
",",
"new",
"NonBlockingHashMap",
"<",
"Long",
",",
... | Please be noted that this function will be called from Site thread, where
most other functions in the class are from StatsAgent thread.
Need to release references to catalog related stats sources
to avoid hoarding references to the catalog. | [
"Please",
"be",
"noted",
"that",
"this",
"function",
"will",
"be",
"called",
"from",
"Site",
"thread",
"where",
"most",
"other",
"functions",
"in",
"the",
"class",
"are",
"from",
"StatsAgent",
"thread",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StatsAgent.java#L307-L311 | train |
VoltDB/voltdb | src/frontend/org/voltcore/agreement/AgreementTxnIdSafetyState.java | AgreementTxnIdSafetyState.addState | public void addState(long agreementHSId) {
SiteState ss = m_stateBySite.get(agreementHSId);
if (ss != null) return;
ss = new SiteState();
ss.hsId = agreementHSId;
ss.newestConfirmedTxnId = m_newestConfirmedTxnId;
m_stateBySite.put(agreementHSId, ss);
} | java | public void addState(long agreementHSId) {
SiteState ss = m_stateBySite.get(agreementHSId);
if (ss != null) return;
ss = new SiteState();
ss.hsId = agreementHSId;
ss.newestConfirmedTxnId = m_newestConfirmedTxnId;
m_stateBySite.put(agreementHSId, ss);
} | [
"public",
"void",
"addState",
"(",
"long",
"agreementHSId",
")",
"{",
"SiteState",
"ss",
"=",
"m_stateBySite",
".",
"get",
"(",
"agreementHSId",
")",
";",
"if",
"(",
"ss",
"!=",
"null",
")",
"return",
";",
"ss",
"=",
"new",
"SiteState",
"(",
")",
";",
... | Once a failed node is rejoined, put it's sites back into
all of the data structures here.
@param executorSiteId
@param partitionId | [
"Once",
"a",
"failed",
"node",
"is",
"rejoined",
"put",
"it",
"s",
"sites",
"back",
"into",
"all",
"of",
"the",
"data",
"structures",
"here",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltcore/agreement/AgreementTxnIdSafetyState.java#L107-L114 | train |
VoltDB/voltdb | src/frontend/org/voltdb/iv2/Scoreboard.java | Scoreboard.pollFirstCompletionTask | public Pair<CompleteTransactionTask, Boolean> pollFirstCompletionTask(CompletionCounter nextTaskCounter) {
// remove from the head
Pair<CompleteTransactionTask, Boolean> pair = m_compTasks.pollFirstEntry().getValue();
if (m_compTasks.isEmpty()) {
return pair;
}
// ch... | java | public Pair<CompleteTransactionTask, Boolean> pollFirstCompletionTask(CompletionCounter nextTaskCounter) {
// remove from the head
Pair<CompleteTransactionTask, Boolean> pair = m_compTasks.pollFirstEntry().getValue();
if (m_compTasks.isEmpty()) {
return pair;
}
// ch... | [
"public",
"Pair",
"<",
"CompleteTransactionTask",
",",
"Boolean",
">",
"pollFirstCompletionTask",
"(",
"CompletionCounter",
"nextTaskCounter",
")",
"{",
"// remove from the head",
"Pair",
"<",
"CompleteTransactionTask",
",",
"Boolean",
">",
"pair",
"=",
"m_compTasks",
"... | Remove the CompleteTransactionTask from the head and count the next CompleteTransactionTask
@param nextTaskCounter CompletionCounter
@return the removed CompleteTransactionTask | [
"Remove",
"the",
"CompleteTransactionTask",
"from",
"the",
"head",
"and",
"count",
"the",
"next",
"CompleteTransactionTask"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/iv2/Scoreboard.java#L75-L94 | train |
VoltDB/voltdb | src/frontend/org/voltdb/iv2/Scoreboard.java | Scoreboard.isComparable | private static boolean isComparable(CompleteTransactionTask c1, CompleteTransactionTask c2) {
return c1.getMsgTxnId() == c2.getMsgTxnId() &&
MpRestartSequenceGenerator.isForRestart(c1.getTimestamp()) ==
MpRestartSequenceGenerator.isForRestart(c2.getTimestamp());
} | java | private static boolean isComparable(CompleteTransactionTask c1, CompleteTransactionTask c2) {
return c1.getMsgTxnId() == c2.getMsgTxnId() &&
MpRestartSequenceGenerator.isForRestart(c1.getTimestamp()) ==
MpRestartSequenceGenerator.isForRestart(c2.getTimestamp());
} | [
"private",
"static",
"boolean",
"isComparable",
"(",
"CompleteTransactionTask",
"c1",
",",
"CompleteTransactionTask",
"c2",
")",
"{",
"return",
"c1",
".",
"getMsgTxnId",
"(",
")",
"==",
"c2",
".",
"getMsgTxnId",
"(",
")",
"&&",
"MpRestartSequenceGenerator",
".",
... | 4) restart completion and repair completion can't overwrite each other | [
"4",
")",
"restart",
"completion",
"and",
"repair",
"completion",
"can",
"t",
"overwrite",
"each",
"other"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/iv2/Scoreboard.java#L123-L127 | train |
VoltDB/voltdb | src/frontend/org/voltdb/iv2/Scoreboard.java | Scoreboard.matchCompleteTransactionTask | public boolean matchCompleteTransactionTask(long txnId, long timestamp) {
if (!m_compTasks.isEmpty()) {
long lowestTxnId = m_compTasks.firstKey();
if (txnId == lowestTxnId) {
Pair<CompleteTransactionTask, Boolean> pair = m_compTasks.get(lowestTxnId);
retur... | java | public boolean matchCompleteTransactionTask(long txnId, long timestamp) {
if (!m_compTasks.isEmpty()) {
long lowestTxnId = m_compTasks.firstKey();
if (txnId == lowestTxnId) {
Pair<CompleteTransactionTask, Boolean> pair = m_compTasks.get(lowestTxnId);
retur... | [
"public",
"boolean",
"matchCompleteTransactionTask",
"(",
"long",
"txnId",
",",
"long",
"timestamp",
")",
"{",
"if",
"(",
"!",
"m_compTasks",
".",
"isEmpty",
"(",
")",
")",
"{",
"long",
"lowestTxnId",
"=",
"m_compTasks",
".",
"firstKey",
"(",
")",
";",
"if... | Only match CompleteTransactionTask at head of the queue | [
"Only",
"match",
"CompleteTransactionTask",
"at",
"head",
"of",
"the",
"queue"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/iv2/Scoreboard.java#L144-L153 | train |
VoltDB/voltdb | src/frontend/org/voltdb/DRRoleStats.java | DRRoleStats.aggregateStats | public static VoltTable aggregateStats(VoltTable stats) throws IllegalArgumentException
{
stats.resetRowPosition();
if (stats.getRowCount() == 0) {
return stats;
}
String role = null;
Map<Byte, State> states = new TreeMap<>();
while (stats.advanceRow()) {... | java | public static VoltTable aggregateStats(VoltTable stats) throws IllegalArgumentException
{
stats.resetRowPosition();
if (stats.getRowCount() == 0) {
return stats;
}
String role = null;
Map<Byte, State> states = new TreeMap<>();
while (stats.advanceRow()) {... | [
"public",
"static",
"VoltTable",
"aggregateStats",
"(",
"VoltTable",
"stats",
")",
"throws",
"IllegalArgumentException",
"{",
"stats",
".",
"resetRowPosition",
"(",
")",
";",
"if",
"(",
"stats",
".",
"getRowCount",
"(",
")",
"==",
"0",
")",
"{",
"return",
"s... | Aggregates DRROLE statistics reported by multiple nodes into a single
cluster-wide row. The role column should be the same across all
nodes. The state column may defer slightly and it uses the same logical
AND-ish operation to combine the states.
This method modifies the VoltTable in place.
@param stats Statistics fro... | [
"Aggregates",
"DRROLE",
"statistics",
"reported",
"by",
"multiple",
"nodes",
"into",
"a",
"single",
"cluster",
"-",
"wide",
"row",
".",
"The",
"role",
"column",
"should",
"be",
"the",
"same",
"across",
"all",
"nodes",
".",
"The",
"state",
"column",
"may",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/DRRoleStats.java#L169-L202 | train |
VoltDB/voltdb | src/frontend/org/voltdb/jdbc/Resources.java | Resources.getString | public static String getString(String key)
{
if (RESOURCE_BUNDLE == null)
throw new RuntimeException("Localized messages from resource bundle '" + BUNDLE_NAME + "' not loaded during initialization of driver.");
try
{
if (key == null)
throw new Illegal... | java | public static String getString(String key)
{
if (RESOURCE_BUNDLE == null)
throw new RuntimeException("Localized messages from resource bundle '" + BUNDLE_NAME + "' not loaded during initialization of driver.");
try
{
if (key == null)
throw new Illegal... | [
"public",
"static",
"String",
"getString",
"(",
"String",
"key",
")",
"{",
"if",
"(",
"RESOURCE_BUNDLE",
"==",
"null",
")",
"throw",
"new",
"RuntimeException",
"(",
"\"Localized messages from resource bundle '\"",
"+",
"BUNDLE_NAME",
"+",
"\"' not loaded during initiali... | Returns the localized message for the given message key
@param key
the message key
@return The localized message for the key | [
"Returns",
"the",
"localized",
"message",
"for",
"the",
"given",
"message",
"key"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/jdbc/Resources.java#L64-L84 | train |
VoltDB/voltdb | src/frontend/org/voltdb/sysprocs/saverestore/SnapshotWritePlan.java | SnapshotWritePlan.createAllDevNullTargets | public void createAllDevNullTargets(Exception lastWriteException)
{
Map<Integer, SnapshotDataTarget> targets = Maps.newHashMap();
final AtomicInteger numTargets = new AtomicInteger();
for (Deque<SnapshotTableTask> tasksForSite : m_taskListsForHSIds.values()) {
for (SnapshotTable... | java | public void createAllDevNullTargets(Exception lastWriteException)
{
Map<Integer, SnapshotDataTarget> targets = Maps.newHashMap();
final AtomicInteger numTargets = new AtomicInteger();
for (Deque<SnapshotTableTask> tasksForSite : m_taskListsForHSIds.values()) {
for (SnapshotTable... | [
"public",
"void",
"createAllDevNullTargets",
"(",
"Exception",
"lastWriteException",
")",
"{",
"Map",
"<",
"Integer",
",",
"SnapshotDataTarget",
">",
"targets",
"=",
"Maps",
".",
"newHashMap",
"(",
")",
";",
"final",
"AtomicInteger",
"numTargets",
"=",
"new",
"A... | In case the deferred setup phase fails, some data targets may have not been created yet.
This method will close all existing data targets and replace all with DevNullDataTargets
so that snapshot can be drained. | [
"In",
"case",
"the",
"deferred",
"setup",
"phase",
"fails",
"some",
"data",
"targets",
"may",
"have",
"not",
"been",
"created",
"yet",
".",
"This",
"method",
"will",
"close",
"all",
"existing",
"data",
"targets",
"and",
"replace",
"all",
"with",
"DevNullData... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/sysprocs/saverestore/SnapshotWritePlan.java#L170-L203 | train |
VoltDB/voltdb | src/frontend/org/voltdb/sysprocs/UpdateCore.java | UpdateCore.collapseSets | private Map<String, Boolean> collapseSets(List<List<String>> allTableSets) {
Map<String, Boolean> answer = new TreeMap<>();
for (List<String> tables : allTableSets) {
for (String table : tables) {
answer.put(table, false);
}
}
return answer;
} | java | private Map<String, Boolean> collapseSets(List<List<String>> allTableSets) {
Map<String, Boolean> answer = new TreeMap<>();
for (List<String> tables : allTableSets) {
for (String table : tables) {
answer.put(table, false);
}
}
return answer;
} | [
"private",
"Map",
"<",
"String",
",",
"Boolean",
">",
"collapseSets",
"(",
"List",
"<",
"List",
"<",
"String",
">",
">",
"allTableSets",
")",
"{",
"Map",
"<",
"String",
",",
"Boolean",
">",
"answer",
"=",
"new",
"TreeMap",
"<>",
"(",
")",
";",
"for",... | Take a list of list of table names and collapse into a map
which maps all table names to false. We will set the correct
values later on. We just want to get the structure right now.
Note that tables may be named multiple time in the lists of
lists of tables. Everything gets mapped to false, so we don't
care.
@param... | [
"Take",
"a",
"list",
"of",
"list",
"of",
"table",
"names",
"and",
"collapse",
"into",
"a",
"map",
"which",
"maps",
"all",
"table",
"names",
"to",
"false",
".",
"We",
"will",
"set",
"the",
"correct",
"values",
"later",
"on",
".",
"We",
"just",
"want",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/sysprocs/UpdateCore.java#L183-L191 | train |
VoltDB/voltdb | src/frontend/org/voltdb/sysprocs/UpdateCore.java | UpdateCore.decodeTables | private List<List<String>> decodeTables(String[] tablesThatMustBeEmpty) {
List<List<String>> answer = new ArrayList<>();
for (String tableSet : tablesThatMustBeEmpty) {
String tableNames[] = tableSet.split("\\+");
answer.add(Arrays.asList(tableNames));
}
return an... | java | private List<List<String>> decodeTables(String[] tablesThatMustBeEmpty) {
List<List<String>> answer = new ArrayList<>();
for (String tableSet : tablesThatMustBeEmpty) {
String tableNames[] = tableSet.split("\\+");
answer.add(Arrays.asList(tableNames));
}
return an... | [
"private",
"List",
"<",
"List",
"<",
"String",
">",
">",
"decodeTables",
"(",
"String",
"[",
"]",
"tablesThatMustBeEmpty",
")",
"{",
"List",
"<",
"List",
"<",
"String",
">>",
"answer",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"for",
"(",
"String",... | Decode sets of names encoded as by concatenation with plus signs
into lists of lists of strings. Preserve the order, since we need
it to match to error messages later on.
@param tablesThatMustBeEmpty
@return The decoded lists. | [
"Decode",
"sets",
"of",
"names",
"encoded",
"as",
"by",
"concatenation",
"with",
"plus",
"signs",
"into",
"lists",
"of",
"lists",
"of",
"strings",
".",
"Preserve",
"the",
"order",
"since",
"we",
"need",
"it",
"to",
"match",
"to",
"error",
"messages",
"late... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/sysprocs/UpdateCore.java#L201-L208 | train |
VoltDB/voltdb | src/frontend/org/voltdb/sysprocs/Shutdown.java | Shutdown.run | public VoltTable[] run(SystemProcedureExecutionContext ctx) {
createAndExecuteSysProcPlan(SysProcFragmentId.PF_shutdownSync, SysProcFragmentId.PF_shutdownSyncDone);
SynthesizedPlanFragment pfs[] = new SynthesizedPlanFragment[] {
new SynthesizedPlanFragment(SysProcFragmentId.PF_shutdownC... | java | public VoltTable[] run(SystemProcedureExecutionContext ctx) {
createAndExecuteSysProcPlan(SysProcFragmentId.PF_shutdownSync, SysProcFragmentId.PF_shutdownSyncDone);
SynthesizedPlanFragment pfs[] = new SynthesizedPlanFragment[] {
new SynthesizedPlanFragment(SysProcFragmentId.PF_shutdownC... | [
"public",
"VoltTable",
"[",
"]",
"run",
"(",
"SystemProcedureExecutionContext",
"ctx",
")",
"{",
"createAndExecuteSysProcPlan",
"(",
"SysProcFragmentId",
".",
"PF_shutdownSync",
",",
"SysProcFragmentId",
".",
"PF_shutdownSyncDone",
")",
";",
"SynthesizedPlanFragment",
"pf... | Begin an un-graceful shutdown.
@param ctx Internal parameter not exposed to the end-user.
@return Never returned, no he never returned... | [
"Begin",
"an",
"un",
"-",
"graceful",
"shutdown",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/sysprocs/Shutdown.java#L126-L134 | train |
VoltDB/voltdb | src/frontend/org/voltdb/jdbc/JDBC4ClientConnection.java | JDBC4ClientConnection.drain | public void drain() throws InterruptedException, IOException {
ClientImpl currentClient = this.getClient();
if (currentClient == null) {
throw new IOException("Client is unavailable for drain().");
}
currentClient.drain();
} | java | public void drain() throws InterruptedException, IOException {
ClientImpl currentClient = this.getClient();
if (currentClient == null) {
throw new IOException("Client is unavailable for drain().");
}
currentClient.drain();
} | [
"public",
"void",
"drain",
"(",
")",
"throws",
"InterruptedException",
",",
"IOException",
"{",
"ClientImpl",
"currentClient",
"=",
"this",
".",
"getClient",
"(",
")",
";",
"if",
"(",
"currentClient",
"==",
"null",
")",
"{",
"throw",
"new",
"IOException",
"(... | Block the current thread until all queued stored procedure invocations have received
responses or there are no more connections to the cluster
@throws InterruptedException
@throws IOException
@see Client#drain() | [
"Block",
"the",
"current",
"thread",
"until",
"all",
"queued",
"stored",
"procedure",
"invocations",
"have",
"received",
"responses",
"or",
"there",
"are",
"no",
"more",
"connections",
"to",
"the",
"cluster"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/jdbc/JDBC4ClientConnection.java#L503-L509 | train |
VoltDB/voltdb | src/frontend/org/voltdb/jdbc/JDBC4ClientConnection.java | JDBC4ClientConnection.backpressureBarrier | public void backpressureBarrier() throws InterruptedException, IOException {
ClientImpl currentClient = this.getClient();
if (currentClient == null) {
throw new IOException("Client is unavailable for backpressureBarrier().");
}
currentClient.backpressureBarrier();
} | java | public void backpressureBarrier() throws InterruptedException, IOException {
ClientImpl currentClient = this.getClient();
if (currentClient == null) {
throw new IOException("Client is unavailable for backpressureBarrier().");
}
currentClient.backpressureBarrier();
} | [
"public",
"void",
"backpressureBarrier",
"(",
")",
"throws",
"InterruptedException",
",",
"IOException",
"{",
"ClientImpl",
"currentClient",
"=",
"this",
".",
"getClient",
"(",
")",
";",
"if",
"(",
"currentClient",
"==",
"null",
")",
"{",
"throw",
"new",
"IOEx... | Blocks the current thread until there is no more backpressure or there are no more
connections to the database
@throws InterruptedException
@throws IOException | [
"Blocks",
"the",
"current",
"thread",
"until",
"there",
"is",
"no",
"more",
"backpressure",
"or",
"there",
"are",
"no",
"more",
"connections",
"to",
"the",
"database"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/jdbc/JDBC4ClientConnection.java#L518-L524 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/navigator/RowSetNavigator.java | RowSetNavigator.absolute | public boolean absolute(int position) {
if (position < 0) {
position += size;
}
if (position < 0) {
beforeFirst();
return false;
}
if (position > size) {
afterLast();
return false;
}
if (size == 0) ... | java | public boolean absolute(int position) {
if (position < 0) {
position += size;
}
if (position < 0) {
beforeFirst();
return false;
}
if (position > size) {
afterLast();
return false;
}
if (size == 0) ... | [
"public",
"boolean",
"absolute",
"(",
"int",
"position",
")",
"{",
"if",
"(",
"position",
"<",
"0",
")",
"{",
"position",
"+=",
"size",
";",
"}",
"if",
"(",
"position",
"<",
"0",
")",
"{",
"beforeFirst",
"(",
")",
";",
"return",
"false",
";",
"}",
... | Uses similar semantics to java.sql.ResultSet except this is 0 based.
When position is 0 or positive, it is from the start; when negative,
it is from end | [
"Uses",
"similar",
"semantics",
"to",
"java",
".",
"sql",
".",
"ResultSet",
"except",
"this",
"is",
"0",
"based",
".",
"When",
"position",
"is",
"0",
"or",
"positive",
"it",
"is",
"from",
"the",
"start",
";",
"when",
"negative",
"it",
"is",
"from",
"en... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/navigator/RowSetNavigator.java#L215-L247 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/exampleutils/AppHelper.java | AppHelper.printErrorAndQuit | private void printErrorAndQuit(String message)
{
System.out.println(message + "\n-------------------------------------------------------------------------------------\n");
printUsage();
System.exit(-1);
} | java | private void printErrorAndQuit(String message)
{
System.out.println(message + "\n-------------------------------------------------------------------------------------\n");
printUsage();
System.exit(-1);
} | [
"private",
"void",
"printErrorAndQuit",
"(",
"String",
"message",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"message",
"+",
"\"\\n-------------------------------------------------------------------------------------\\n\"",
")",
";",
"printUsage",
"(",
")",
";",... | Prints out an error message and the application usage print-out, then terminates the application. | [
"Prints",
"out",
"an",
"error",
"message",
"and",
"the",
"application",
"usage",
"print",
"-",
"out",
"then",
"terminates",
"the",
"application",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/exampleutils/AppHelper.java#L219-L224 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/exampleutils/AppHelper.java | AppHelper.printActualUsage | public AppHelper printActualUsage()
{
System.out.println("-------------------------------------------------------------------------------------");
int maxLength = 24;
for(Argument a : Arguments)
if (maxLength < a.Name.length())
maxLength = a.Name.length();
... | java | public AppHelper printActualUsage()
{
System.out.println("-------------------------------------------------------------------------------------");
int maxLength = 24;
for(Argument a : Arguments)
if (maxLength < a.Name.length())
maxLength = a.Name.length();
... | [
"public",
"AppHelper",
"printActualUsage",
"(",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"-------------------------------------------------------------------------------------\"",
")",
";",
"int",
"maxLength",
"=",
"24",
";",
"for",
"(",
"Argument",
"a",
... | Prints a full list of actual arguments that will be used by the application after interpretation of defaults and actual argument values as passed by the user on the command line.
@return reference to this application helper, allowing command-chaining. | [
"Prints",
"a",
"full",
"list",
"of",
"actual",
"arguments",
"that",
"will",
"be",
"used",
"by",
"the",
"application",
"after",
"interpretation",
"of",
"defaults",
"and",
"actual",
"argument",
"values",
"as",
"passed",
"by",
"the",
"user",
"on",
"the",
"comma... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/exampleutils/AppHelper.java#L231-L246 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/exampleutils/AppHelper.java | AppHelper.byteValue | public byte byteValue(String name)
{
try
{
return Byte.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
... | java | public byte byteValue(String name)
{
try
{
return Byte.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
... | [
"public",
"byte",
"byteValue",
"(",
"String",
"name",
")",
"{",
"try",
"{",
"return",
"Byte",
".",
"valueOf",
"(",
"this",
".",
"getArgumentByName",
"(",
"name",
")",
".",
"Value",
")",
";",
"}",
"catch",
"(",
"NullPointerException",
"npe",
")",
"{",
"... | Retrieves the value of an argument as a byte.
@param name the (case-sensitive) name of the argument to retrieve.
@return the value of the argument cast as a byte. Will terminate the application if a required argument is found missing or the casting call fails, printing out detailed usage. | [
"Retrieves",
"the",
"value",
"of",
"an",
"argument",
"as",
"a",
"byte",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/exampleutils/AppHelper.java#L330-L345 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/exampleutils/AppHelper.java | AppHelper.shortValue | public short shortValue(String name)
{
try
{
return Short.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
... | java | public short shortValue(String name)
{
try
{
return Short.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
... | [
"public",
"short",
"shortValue",
"(",
"String",
"name",
")",
"{",
"try",
"{",
"return",
"Short",
".",
"valueOf",
"(",
"this",
".",
"getArgumentByName",
"(",
"name",
")",
".",
"Value",
")",
";",
"}",
"catch",
"(",
"NullPointerException",
"npe",
")",
"{",
... | Retrieves the value of an argument as a short.
@param name the (case-sensitive) name of the argument to retrieve.
@return the value of the argument cast as a short. Will terminate the application if a required argument is found missing or the casting call fails, printing out detailed usage. | [
"Retrieves",
"the",
"value",
"of",
"an",
"argument",
"as",
"a",
"short",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/exampleutils/AppHelper.java#L353-L368 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/exampleutils/AppHelper.java | AppHelper.intValue | public int intValue(String name)
{
try
{
return Integer.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
... | java | public int intValue(String name)
{
try
{
return Integer.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
... | [
"public",
"int",
"intValue",
"(",
"String",
"name",
")",
"{",
"try",
"{",
"return",
"Integer",
".",
"valueOf",
"(",
"this",
".",
"getArgumentByName",
"(",
"name",
")",
".",
"Value",
")",
";",
"}",
"catch",
"(",
"NullPointerException",
"npe",
")",
"{",
... | Retrieves the value of an argument as a int.
@param name the (case-sensitive) name of the argument to retrieve.
@return the value of the argument cast as a int. Will terminate the application if a required argument is found missing or the casting call fails, printing out detailed usage. | [
"Retrieves",
"the",
"value",
"of",
"an",
"argument",
"as",
"a",
"int",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/exampleutils/AppHelper.java#L376-L391 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/exampleutils/AppHelper.java | AppHelper.longValue | public long longValue(String name)
{
try
{
return Long.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
... | java | public long longValue(String name)
{
try
{
return Long.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
... | [
"public",
"long",
"longValue",
"(",
"String",
"name",
")",
"{",
"try",
"{",
"return",
"Long",
".",
"valueOf",
"(",
"this",
".",
"getArgumentByName",
"(",
"name",
")",
".",
"Value",
")",
";",
"}",
"catch",
"(",
"NullPointerException",
"npe",
")",
"{",
"... | Retrieves the value of an argument as a long.
@param name the (case-sensitive) name of the argument to retrieve.
@return the value of the argument cast as a long. Will terminate the application if a required argument is found missing or the casting call fails, printing out detailed usage. | [
"Retrieves",
"the",
"value",
"of",
"an",
"argument",
"as",
"a",
"long",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/exampleutils/AppHelper.java#L399-L414 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/exampleutils/AppHelper.java | AppHelper.doubleValue | public double doubleValue(String name)
{
try
{
return Double.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x... | java | public double doubleValue(String name)
{
try
{
return Double.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x... | [
"public",
"double",
"doubleValue",
"(",
"String",
"name",
")",
"{",
"try",
"{",
"return",
"Double",
".",
"valueOf",
"(",
"this",
".",
"getArgumentByName",
"(",
"name",
")",
".",
"Value",
")",
";",
"}",
"catch",
"(",
"NullPointerException",
"npe",
")",
"{... | Retrieves the value of an argument as a double.
@param name the (case-sensitive) name of the argument to retrieve.
@return the value of the argument cast as a double. Will terminate the application if a required argument is found missing or the casting call fails, printing out detailed usage. | [
"Retrieves",
"the",
"value",
"of",
"an",
"argument",
"as",
"a",
"double",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/exampleutils/AppHelper.java#L422-L437 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/exampleutils/AppHelper.java | AppHelper.stringValue | public String stringValue(String name)
{
try
{
return this.getArgumentByName(name).Value;
}
catch(Exception npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
return null; // We will never get here: prin... | java | public String stringValue(String name)
{
try
{
return this.getArgumentByName(name).Value;
}
catch(Exception npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
return null; // We will never get here: prin... | [
"public",
"String",
"stringValue",
"(",
"String",
"name",
")",
"{",
"try",
"{",
"return",
"this",
".",
"getArgumentByName",
"(",
"name",
")",
".",
"Value",
";",
"}",
"catch",
"(",
"Exception",
"npe",
")",
"{",
"printErrorAndQuit",
"(",
"String",
".",
"fo... | Retrieves the value of an argument as a string.
@param name the (case-sensitive) name of the argument to retrieve.
@return the value of the argument as a string (as passed on the command line). Will terminate the application if a required argument is found missing, printing out detailed usage. | [
"Retrieves",
"the",
"value",
"of",
"an",
"argument",
"as",
"a",
"string",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/exampleutils/AppHelper.java#L445-L456 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/exampleutils/AppHelper.java | AppHelper.booleanValue | public boolean booleanValue(String name)
{
try
{
return Boolean.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exceptio... | java | public boolean booleanValue(String name)
{
try
{
return Boolean.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exceptio... | [
"public",
"boolean",
"booleanValue",
"(",
"String",
"name",
")",
"{",
"try",
"{",
"return",
"Boolean",
".",
"valueOf",
"(",
"this",
".",
"getArgumentByName",
"(",
"name",
")",
".",
"Value",
")",
";",
"}",
"catch",
"(",
"NullPointerException",
"npe",
")",
... | Retrieves the value of an argument as a boolean.
@param name the (case-sensitive) name of the argument to retrieve.
@return the value of the argument cast as a boolean. Will terminate the application if a required argument is found missing or the casting call fails, printing out detailed usage. | [
"Retrieves",
"the",
"value",
"of",
"an",
"argument",
"as",
"a",
"boolean",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/exampleutils/AppHelper.java#L464-L479 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/util/Tree.java | Tree.setBounds | public void setBounds(int x, int y, int w, int h) {
super.setBounds(x, y, w, h);
iSbHeight = sbHoriz.getPreferredSize().height;
iSbWidth = sbVert.getPreferredSize().width;
iHeight = h - iSbHeight;
iWidth = w - iSbWidth;
sbHoriz.setBounds(0, iHeight, iWidth, iSbHe... | java | public void setBounds(int x, int y, int w, int h) {
super.setBounds(x, y, w, h);
iSbHeight = sbHoriz.getPreferredSize().height;
iSbWidth = sbVert.getPreferredSize().width;
iHeight = h - iSbHeight;
iWidth = w - iSbWidth;
sbHoriz.setBounds(0, iHeight, iWidth, iSbHe... | [
"public",
"void",
"setBounds",
"(",
"int",
"x",
",",
"int",
"y",
",",
"int",
"w",
",",
"int",
"h",
")",
"{",
"super",
".",
"setBounds",
"(",
"x",
",",
"y",
",",
"w",
",",
"h",
")",
";",
"iSbHeight",
"=",
"sbHoriz",
".",
"getPreferredSize",
"(",
... | with additional replacement of deprecated methods | [
"with",
"additional",
"replacement",
"of",
"deprecated",
"methods"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/util/Tree.java#L167-L183 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/VoltTrace.java | VoltTrace.write | private String write(String logDir) throws IOException, ExecutionException, InterruptedException {
final File file = new File(logDir, "trace_" + System.currentTimeMillis() + ".json.gz");
if (file.exists()) {
throw new IOException("Trace file " + file.getAbsolutePath() + " already exists");
... | java | private String write(String logDir) throws IOException, ExecutionException, InterruptedException {
final File file = new File(logDir, "trace_" + System.currentTimeMillis() + ".json.gz");
if (file.exists()) {
throw new IOException("Trace file " + file.getAbsolutePath() + " already exists");
... | [
"private",
"String",
"write",
"(",
"String",
"logDir",
")",
"throws",
"IOException",
",",
"ExecutionException",
",",
"InterruptedException",
"{",
"final",
"File",
"file",
"=",
"new",
"File",
"(",
"logDir",
",",
"\"trace_\"",
"+",
"System",
".",
"currentTimeMilli... | Write the events in the queue to file.
@param logDir The directory to write the file to.
@return The file path if successfully written, or null if the there is
already a write in progress. | [
"Write",
"the",
"events",
"in",
"the",
"queue",
"to",
"file",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/VoltTrace.java#L394-L413 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/VoltTrace.java | VoltTrace.log | public static TraceEventBatch log(Category cat) {
final VoltTrace tracer = s_tracer;
if (tracer != null && tracer.isCategoryEnabled(cat)) {
final TraceEventBatch batch = new TraceEventBatch(cat);
tracer.queueEvent(batch);
return batch;
} else {
ret... | java | public static TraceEventBatch log(Category cat) {
final VoltTrace tracer = s_tracer;
if (tracer != null && tracer.isCategoryEnabled(cat)) {
final TraceEventBatch batch = new TraceEventBatch(cat);
tracer.queueEvent(batch);
return batch;
} else {
ret... | [
"public",
"static",
"TraceEventBatch",
"log",
"(",
"Category",
"cat",
")",
"{",
"final",
"VoltTrace",
"tracer",
"=",
"s_tracer",
";",
"if",
"(",
"tracer",
"!=",
"null",
"&&",
"tracer",
".",
"isCategoryEnabled",
"(",
"cat",
")",
")",
"{",
"final",
"TraceEve... | Create a trace event batch for the given category. The events that go
into this batch should all originate from the same thread.
@param cat The category to write the events to.
@return The batch object to add events to, or null if trace logging for
the category is not enabled. | [
"Create",
"a",
"trace",
"event",
"batch",
"for",
"the",
"given",
"category",
".",
"The",
"events",
"that",
"go",
"into",
"this",
"batch",
"should",
"all",
"originate",
"from",
"the",
"same",
"thread",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/VoltTrace.java#L443-L452 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/VoltTrace.java | VoltTrace.closeAllAndShutdown | public static String closeAllAndShutdown(String logDir, long timeOutMillis) throws IOException {
String path = null;
final VoltTrace tracer = s_tracer;
if (tracer != null) {
if (logDir != null) {
path = dump(logDir);
}
s_tracer = null;
... | java | public static String closeAllAndShutdown(String logDir, long timeOutMillis) throws IOException {
String path = null;
final VoltTrace tracer = s_tracer;
if (tracer != null) {
if (logDir != null) {
path = dump(logDir);
}
s_tracer = null;
... | [
"public",
"static",
"String",
"closeAllAndShutdown",
"(",
"String",
"logDir",
",",
"long",
"timeOutMillis",
")",
"throws",
"IOException",
"{",
"String",
"path",
"=",
"null",
";",
"final",
"VoltTrace",
"tracer",
"=",
"s_tracer",
";",
"if",
"(",
"tracer",
"!=",
... | Close all open files and wait for shutdown.
@param logDir The directory to write the trace events to, null to skip writing to file.
@param timeOutMillis Timeout in milliseconds. Negative to not wait
@return The path to the trace file if written, or null if a write is already in progress. | [
"Close",
"all",
"open",
"files",
"and",
"wait",
"for",
"shutdown",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/VoltTrace.java#L515-L538 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/VoltTrace.java | VoltTrace.start | private static synchronized void start() throws IOException {
if (s_tracer == null) {
final VoltTrace tracer = new VoltTrace();
final Thread thread = new Thread(tracer);
thread.setDaemon(true);
thread.start();
s_tracer = tracer;
}
} | java | private static synchronized void start() throws IOException {
if (s_tracer == null) {
final VoltTrace tracer = new VoltTrace();
final Thread thread = new Thread(tracer);
thread.setDaemon(true);
thread.start();
s_tracer = tracer;
}
} | [
"private",
"static",
"synchronized",
"void",
"start",
"(",
")",
"throws",
"IOException",
"{",
"if",
"(",
"s_tracer",
"==",
"null",
")",
"{",
"final",
"VoltTrace",
"tracer",
"=",
"new",
"VoltTrace",
"(",
")",
";",
"final",
"Thread",
"thread",
"=",
"new",
... | Creates and starts a new tracer. If one already exists, this is a
no-op. Synchronized to prevent multiple threads enabling it at the same
time. | [
"Creates",
"and",
"starts",
"a",
"new",
"tracer",
".",
"If",
"one",
"already",
"exists",
"this",
"is",
"a",
"no",
"-",
"op",
".",
"Synchronized",
"to",
"prevent",
"multiple",
"threads",
"enabling",
"it",
"at",
"the",
"same",
"time",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/VoltTrace.java#L545-L553 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/VoltTrace.java | VoltTrace.dump | public static String dump(String logDir) throws IOException {
String path = null;
final VoltTrace tracer = s_tracer;
if (tracer != null) {
final File dir = new File(logDir);
if (!dir.getParentFile().canWrite() || !dir.getParentFile().canExecute()) {
throw... | java | public static String dump(String logDir) throws IOException {
String path = null;
final VoltTrace tracer = s_tracer;
if (tracer != null) {
final File dir = new File(logDir);
if (!dir.getParentFile().canWrite() || !dir.getParentFile().canExecute()) {
throw... | [
"public",
"static",
"String",
"dump",
"(",
"String",
"logDir",
")",
"throws",
"IOException",
"{",
"String",
"path",
"=",
"null",
";",
"final",
"VoltTrace",
"tracer",
"=",
"s_tracer",
";",
"if",
"(",
"tracer",
"!=",
"null",
")",
"{",
"final",
"File",
"dir... | Write all trace events in the queue to file.
@return The file path if written successfully, or null if a write is already in progress. | [
"Write",
"all",
"trace",
"events",
"in",
"the",
"queue",
"to",
"file",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/VoltTrace.java#L559-L583 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.